From: SourceForge.net <no...@so...> - 2009-09-27 23:57:22
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Tracker Item Submitted) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 5 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: miguel sofer (msofer) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2009-09-28 23:00:30
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Comment added) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 5 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: miguel sofer (msofer) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-29 01:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2009-10-05 00:46:09
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Comment added) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 5 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: miguel sofer (msofer) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 02:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-29 01:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2009-10-05 08:12:38
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Comment added) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 5 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: miguel sofer (msofer) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 10:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 02:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-29 01:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2009-10-20 16:17:27
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Comment added) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 5 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: miguel sofer (msofer) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 18:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 10:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 02:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-29 01:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2009-10-23 01:03:16
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Comment added) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 5 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: miguel sofer (msofer) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-23 03:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 18:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 10:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 02:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-29 01:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2009-10-31 16:01:40
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Comment added) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 5 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: miguel sofer (msofer) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-23 03:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 18:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 10:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 02:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-29 01:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2009-10-31 16:37:43
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Comment added) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 5 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: miguel sofer (msofer) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-23 03:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 18:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 10:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 02:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-29 01:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2009-11-09 13:26:44
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Comment added) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 5 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: miguel sofer (msofer) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-11-09 14:26 Message: Added documentatoin in catch.n and info.n. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-23 03:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 18:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 10:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 02:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-29 01:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2009-12-15 17:42:40
|
Patches item #2868499, was opened at 2009-09-27 19:57 Message generated for change (Settings changed) made by dgp You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None >Priority: 9 Private: No Submitted By: Alexandre Ferrieux (ferrieux) >Assigned to: Don Porter (dgp) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-11-09 08:26 Message: Added documentatoin in catch.n and info.n. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 12:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 12:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-22 21:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 12:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 04:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-04 20:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-28 19:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2010-02-08 10:08:39
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Comment added) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 9 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: Don Porter (dgp) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-02-08 11:08 Message: Patch updated to HEAD. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-11-09 14:26 Message: Added documentatoin in catch.n and info.n. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-23 03:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 18:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 10:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 02:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-29 01:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2010-03-17 00:59:07
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Comment added) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 9 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: Don Porter (dgp) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 01:59 Message: Patch re-updated to HEAD, and now includes two updates suggested by dgp: (a) restriction of -errorstack dict option to TCL_ERROR cases (b) simplification of the internal [lappend] used ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-02-08 11:08 Message: Patch updated to HEAD. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-11-09 14:26 Message: Added documentatoin in catch.n and info.n. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-23 03:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 18:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 10:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 02:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-29 01:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2010-03-17 14:01:29
|
Patches item #2868499, was opened at 2009-09-27 19:57 Message generated for change (Comment added) made by dgp You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 9 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: Don Porter (dgp) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Don Porter (dgp) Date: 2010-03-17 10:01 Message: -errorstack is like -errorcode in that it wants a list argument. This patch suffers from the same bug as 2383005. Both bugs should be fixed. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-16 20:59 Message: Patch re-updated to HEAD, and now includes two updates suggested by dgp: (a) restriction of -errorstack dict option to TCL_ERROR cases (b) simplification of the internal [lappend] used ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-02-08 05:08 Message: Patch updated to HEAD. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-11-09 08:26 Message: Added documentatoin in catch.n and info.n. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 12:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 12:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-22 21:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 12:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 04:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-04 20:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-28 19:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2010-03-17 14:03:45
|
Patches item #2868499, was opened at 2009-09-27 19:57 Message generated for change (Comment added) made by dgp You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 9 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: Don Porter (dgp) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Don Porter (dgp) Date: 2010-03-17 10:03 Message: Need to examine whether Tcl_SaveInterpState and friends need to give the -errorstack dict entry any special treatment like errorInfo and errorCode receive, or whether it's fully covered by the returnOpts dict. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 10:01 Message: -errorstack is like -errorcode in that it wants a list argument. This patch suffers from the same bug as 2383005. Both bugs should be fixed. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-16 20:59 Message: Patch re-updated to HEAD, and now includes two updates suggested by dgp: (a) restriction of -errorstack dict option to TCL_ERROR cases (b) simplification of the internal [lappend] used ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-02-08 05:08 Message: Patch updated to HEAD. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-11-09 08:26 Message: Added documentatoin in catch.n and info.n. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 12:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 12:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-22 21:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 12:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 04:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-04 20:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-28 19:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2010-03-17 14:50:59
|
Patches item #2868499, was opened at 2009-09-27 19:57 Message generated for change (Comment added) made by dgp You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 9 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: Don Porter (dgp) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Don Porter (dgp) Date: 2010-03-17 10:50 Message: TclProcessReturn() does not appear to have anything in it to pull a -errorstack value out of the options dict to be stored in the iPtr->errorstack field. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 10:03 Message: Need to examine whether Tcl_SaveInterpState and friends need to give the -errorstack dict entry any special treatment like errorInfo and errorCode receive, or whether it's fully covered by the returnOpts dict. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 10:01 Message: -errorstack is like -errorcode in that it wants a list argument. This patch suffers from the same bug as 2383005. Both bugs should be fixed. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-16 20:59 Message: Patch re-updated to HEAD, and now includes two updates suggested by dgp: (a) restriction of -errorstack dict option to TCL_ERROR cases (b) simplification of the internal [lappend] used ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-02-08 05:08 Message: Patch updated to HEAD. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-11-09 08:26 Message: Added documentatoin in catch.n and info.n. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 12:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 12:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-22 21:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 12:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 04:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-04 20:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-28 19:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2010-03-17 17:46:12
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Comment added) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 9 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: Don Porter (dgp) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 18:46 Message: No, -errorstack is just a readonly optsDict member. Even Joe, who asked for it in the first place, didn't ask for a [return -errorstack]. Personally I believe(d) that restricting ourselves to [info/interp errorstack] is(was) even better, but I yielded. Question1: do you think that a read-only optsDict member is out of question ? Question2: where's your preference between: (a) a read-write opt (b) no opt, just [info/interp errorstack] ? ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:50 Message: TclProcessReturn() does not appear to have anything in it to pull a -errorstack value out of the options dict to be stored in the iPtr->errorstack field. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:03 Message: Need to examine whether Tcl_SaveInterpState and friends need to give the -errorstack dict entry any special treatment like errorInfo and errorCode receive, or whether it's fully covered by the returnOpts dict. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:01 Message: -errorstack is like -errorcode in that it wants a list argument. This patch suffers from the same bug as 2383005. Both bugs should be fixed. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 01:59 Message: Patch re-updated to HEAD, and now includes two updates suggested by dgp: (a) restriction of -errorstack dict option to TCL_ERROR cases (b) simplification of the internal [lappend] used ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-02-08 11:08 Message: Patch updated to HEAD. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-11-09 14:26 Message: Added documentatoin in catch.n and info.n. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-23 03:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 18:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 10:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 02:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-29 01:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2010-03-17 17:52:21
|
Patches item #2868499, was opened at 2009-09-27 19:57 Message generated for change (Comment added) made by dgp You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 9 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: Don Porter (dgp) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Don Porter (dgp) Date: 2010-03-17 13:52 Message: um, that's novel. :) I might be convinced to make this one special, but in that case I don't think the right thing to do with [return -errorstack] is to just let it silently fail. If we are to disallow it, raise an error. I was wondering myself about whether [info errostack] would be sufficient. The issue appears to come down to whether or not the value of -errorstack ought to be considered part of the "state" of the interp -- those values saved and restored by Tcl_*InterpState() and cable to be [catch]-ed and re-raised by [return -options]. Since you call -errorstack a sister of -errorinfo, my first assumption is that it is part of that state, and needs to be part of that save/restore capability, and for that reason needs to be writable via the [return] command. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 13:46 Message: No, -errorstack is just a readonly optsDict member. Even Joe, who asked for it in the first place, didn't ask for a [return -errorstack]. Personally I believe(d) that restricting ourselves to [info/interp errorstack] is(was) even better, but I yielded. Question1: do you think that a read-only optsDict member is out of question ? Question2: where's your preference between: (a) a read-write opt (b) no opt, just [info/interp errorstack] ? ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 10:50 Message: TclProcessReturn() does not appear to have anything in it to pull a -errorstack value out of the options dict to be stored in the iPtr->errorstack field. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 10:03 Message: Need to examine whether Tcl_SaveInterpState and friends need to give the -errorstack dict entry any special treatment like errorInfo and errorCode receive, or whether it's fully covered by the returnOpts dict. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 10:01 Message: -errorstack is like -errorcode in that it wants a list argument. This patch suffers from the same bug as 2383005. Both bugs should be fixed. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-16 20:59 Message: Patch re-updated to HEAD, and now includes two updates suggested by dgp: (a) restriction of -errorstack dict option to TCL_ERROR cases (b) simplification of the internal [lappend] used ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-02-08 05:08 Message: Patch updated to HEAD. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-11-09 08:26 Message: Added documentatoin in catch.n and info.n. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 12:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 12:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-22 21:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 12:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 04:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-04 20:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-28 19:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2010-03-17 20:47:04
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Comment added) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 9 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: Don Porter (dgp) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 21:47 Message: Ah, OK. Just noticed that [return -foo bar something] just populates the dict with key -foo and value bar. I had wrongly assumed that only the meaningful ones were passed, erroring on others. Anyway I accept the argument of symmetry with errorinfo. Will shortly upload an update including the r/w option. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 18:52 Message: um, that's novel. :) I might be convinced to make this one special, but in that case I don't think the right thing to do with [return -errorstack] is to just let it silently fail. If we are to disallow it, raise an error. I was wondering myself about whether [info errostack] would be sufficient. The issue appears to come down to whether or not the value of -errorstack ought to be considered part of the "state" of the interp -- those values saved and restored by Tcl_*InterpState() and cable to be [catch]-ed and re-raised by [return -options]. Since you call -errorstack a sister of -errorinfo, my first assumption is that it is part of that state, and needs to be part of that save/restore capability, and for that reason needs to be writable via the [return] command. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 18:46 Message: No, -errorstack is just a readonly optsDict member. Even Joe, who asked for it in the first place, didn't ask for a [return -errorstack]. Personally I believe(d) that restricting ourselves to [info/interp errorstack] is(was) even better, but I yielded. Question1: do you think that a read-only optsDict member is out of question ? Question2: where's your preference between: (a) a read-write opt (b) no opt, just [info/interp errorstack] ? ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:50 Message: TclProcessReturn() does not appear to have anything in it to pull a -errorstack value out of the options dict to be stored in the iPtr->errorstack field. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:03 Message: Need to examine whether Tcl_SaveInterpState and friends need to give the -errorstack dict entry any special treatment like errorInfo and errorCode receive, or whether it's fully covered by the returnOpts dict. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:01 Message: -errorstack is like -errorcode in that it wants a list argument. This patch suffers from the same bug as 2383005. Both bugs should be fixed. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 01:59 Message: Patch re-updated to HEAD, and now includes two updates suggested by dgp: (a) restriction of -errorstack dict option to TCL_ERROR cases (b) simplification of the internal [lappend] used ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-02-08 11:08 Message: Patch updated to HEAD. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-11-09 14:26 Message: Added documentatoin in catch.n and info.n. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-23 03:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 18:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 10:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 02:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-29 01:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2010-03-17 22:39:45
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Comment added) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 9 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: Don Porter (dgp) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 23:39 Message: Attached patch doing as promised, [return -errorstack], and a new test case checking that this affects [info errorstack] on subsequent [catch] as expected. Note that it also includes the fix for 2383005. Note however, that in both cases if a non-list like "{}a" is passed to [return -errorstack/errorcode], the resulting error message remains the final arg of [return -code error ...] instead of 'list element in braces followed by "a" instead of space'. I suspect this is the work of Tcl_TransferResult but I'm not familiar with that part, I'd appreciate help (ipso facto solving 2383005). ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 21:47 Message: Ah, OK. Just noticed that [return -foo bar something] just populates the dict with key -foo and value bar. I had wrongly assumed that only the meaningful ones were passed, erroring on others. Anyway I accept the argument of symmetry with errorinfo. Will shortly upload an update including the r/w option. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 18:52 Message: um, that's novel. :) I might be convinced to make this one special, but in that case I don't think the right thing to do with [return -errorstack] is to just let it silently fail. If we are to disallow it, raise an error. I was wondering myself about whether [info errostack] would be sufficient. The issue appears to come down to whether or not the value of -errorstack ought to be considered part of the "state" of the interp -- those values saved and restored by Tcl_*InterpState() and cable to be [catch]-ed and re-raised by [return -options]. Since you call -errorstack a sister of -errorinfo, my first assumption is that it is part of that state, and needs to be part of that save/restore capability, and for that reason needs to be writable via the [return] command. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 18:46 Message: No, -errorstack is just a readonly optsDict member. Even Joe, who asked for it in the first place, didn't ask for a [return -errorstack]. Personally I believe(d) that restricting ourselves to [info/interp errorstack] is(was) even better, but I yielded. Question1: do you think that a read-only optsDict member is out of question ? Question2: where's your preference between: (a) a read-write opt (b) no opt, just [info/interp errorstack] ? ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:50 Message: TclProcessReturn() does not appear to have anything in it to pull a -errorstack value out of the options dict to be stored in the iPtr->errorstack field. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:03 Message: Need to examine whether Tcl_SaveInterpState and friends need to give the -errorstack dict entry any special treatment like errorInfo and errorCode receive, or whether it's fully covered by the returnOpts dict. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:01 Message: -errorstack is like -errorcode in that it wants a list argument. This patch suffers from the same bug as 2383005. Both bugs should be fixed. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 01:59 Message: Patch re-updated to HEAD, and now includes two updates suggested by dgp: (a) restriction of -errorstack dict option to TCL_ERROR cases (b) simplification of the internal [lappend] used ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-02-08 11:08 Message: Patch updated to HEAD. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-11-09 14:26 Message: Added documentatoin in catch.n and info.n. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-23 03:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 18:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 10:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 02:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-29 01:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2010-03-17 22:57:58
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Comment added) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 9 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: Don Porter (dgp) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 23:57 Message: Let's handle that tiny issue in the bug 2383005 itself. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 23:39 Message: Attached patch doing as promised, [return -errorstack], and a new test case checking that this affects [info errorstack] on subsequent [catch] as expected. Note that it also includes the fix for 2383005. Note however, that in both cases if a non-list like "{}a" is passed to [return -errorstack/errorcode], the resulting error message remains the final arg of [return -code error ...] instead of 'list element in braces followed by "a" instead of space'. I suspect this is the work of Tcl_TransferResult but I'm not familiar with that part, I'd appreciate help (ipso facto solving 2383005). ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 21:47 Message: Ah, OK. Just noticed that [return -foo bar something] just populates the dict with key -foo and value bar. I had wrongly assumed that only the meaningful ones were passed, erroring on others. Anyway I accept the argument of symmetry with errorinfo. Will shortly upload an update including the r/w option. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 18:52 Message: um, that's novel. :) I might be convinced to make this one special, but in that case I don't think the right thing to do with [return -errorstack] is to just let it silently fail. If we are to disallow it, raise an error. I was wondering myself about whether [info errostack] would be sufficient. The issue appears to come down to whether or not the value of -errorstack ought to be considered part of the "state" of the interp -- those values saved and restored by Tcl_*InterpState() and cable to be [catch]-ed and re-raised by [return -options]. Since you call -errorstack a sister of -errorinfo, my first assumption is that it is part of that state, and needs to be part of that save/restore capability, and for that reason needs to be writable via the [return] command. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 18:46 Message: No, -errorstack is just a readonly optsDict member. Even Joe, who asked for it in the first place, didn't ask for a [return -errorstack]. Personally I believe(d) that restricting ourselves to [info/interp errorstack] is(was) even better, but I yielded. Question1: do you think that a read-only optsDict member is out of question ? Question2: where's your preference between: (a) a read-write opt (b) no opt, just [info/interp errorstack] ? ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:50 Message: TclProcessReturn() does not appear to have anything in it to pull a -errorstack value out of the options dict to be stored in the iPtr->errorstack field. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:03 Message: Need to examine whether Tcl_SaveInterpState and friends need to give the -errorstack dict entry any special treatment like errorInfo and errorCode receive, or whether it's fully covered by the returnOpts dict. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:01 Message: -errorstack is like -errorcode in that it wants a list argument. This patch suffers from the same bug as 2383005. Both bugs should be fixed. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 01:59 Message: Patch re-updated to HEAD, and now includes two updates suggested by dgp: (a) restriction of -errorstack dict option to TCL_ERROR cases (b) simplification of the internal [lappend] used ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-02-08 11:08 Message: Patch updated to HEAD. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-11-09 14:26 Message: Added documentatoin in catch.n and info.n. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-23 03:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 18:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 10:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 02:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-29 01:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2010-03-18 23:08:43
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Comment added) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 9 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: Don Porter (dgp) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-19 00:08 Message: Patch updated to include the cleaner MergeRetOpts-based check for listness of -errorstack values, and a test case. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 23:57 Message: Let's handle that tiny issue in the bug 2383005 itself. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 23:39 Message: Attached patch doing as promised, [return -errorstack], and a new test case checking that this affects [info errorstack] on subsequent [catch] as expected. Note that it also includes the fix for 2383005. Note however, that in both cases if a non-list like "{}a" is passed to [return -errorstack/errorcode], the resulting error message remains the final arg of [return -code error ...] instead of 'list element in braces followed by "a" instead of space'. I suspect this is the work of Tcl_TransferResult but I'm not familiar with that part, I'd appreciate help (ipso facto solving 2383005). ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 21:47 Message: Ah, OK. Just noticed that [return -foo bar something] just populates the dict with key -foo and value bar. I had wrongly assumed that only the meaningful ones were passed, erroring on others. Anyway I accept the argument of symmetry with errorinfo. Will shortly upload an update including the r/w option. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 18:52 Message: um, that's novel. :) I might be convinced to make this one special, but in that case I don't think the right thing to do with [return -errorstack] is to just let it silently fail. If we are to disallow it, raise an error. I was wondering myself about whether [info errostack] would be sufficient. The issue appears to come down to whether or not the value of -errorstack ought to be considered part of the "state" of the interp -- those values saved and restored by Tcl_*InterpState() and cable to be [catch]-ed and re-raised by [return -options]. Since you call -errorstack a sister of -errorinfo, my first assumption is that it is part of that state, and needs to be part of that save/restore capability, and for that reason needs to be writable via the [return] command. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 18:46 Message: No, -errorstack is just a readonly optsDict member. Even Joe, who asked for it in the first place, didn't ask for a [return -errorstack]. Personally I believe(d) that restricting ourselves to [info/interp errorstack] is(was) even better, but I yielded. Question1: do you think that a read-only optsDict member is out of question ? Question2: where's your preference between: (a) a read-write opt (b) no opt, just [info/interp errorstack] ? ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:50 Message: TclProcessReturn() does not appear to have anything in it to pull a -errorstack value out of the options dict to be stored in the iPtr->errorstack field. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:03 Message: Need to examine whether Tcl_SaveInterpState and friends need to give the -errorstack dict entry any special treatment like errorInfo and errorCode receive, or whether it's fully covered by the returnOpts dict. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:01 Message: -errorstack is like -errorcode in that it wants a list argument. This patch suffers from the same bug as 2383005. Both bugs should be fixed. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 01:59 Message: Patch re-updated to HEAD, and now includes two updates suggested by dgp: (a) restriction of -errorstack dict option to TCL_ERROR cases (b) simplification of the internal [lappend] used ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-02-08 11:08 Message: Patch updated to HEAD. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-11-09 14:26 Message: Added documentatoin in catch.n and info.n. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-23 03:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 18:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 10:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 02:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-29 01:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2010-03-23 21:25:07
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Comment added) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 9 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: Don Porter (dgp) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-23 22:25 Message: Thanks to Miguel for the hint: varFramePtr != framePtr is the simple check for [uplevel] spurious echoes. Patch updated. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-19 00:08 Message: Patch updated to include the cleaner MergeRetOpts-based check for listness of -errorstack values, and a test case. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 23:57 Message: Let's handle that tiny issue in the bug 2383005 itself. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 23:39 Message: Attached patch doing as promised, [return -errorstack], and a new test case checking that this affects [info errorstack] on subsequent [catch] as expected. Note that it also includes the fix for 2383005. Note however, that in both cases if a non-list like "{}a" is passed to [return -errorstack/errorcode], the resulting error message remains the final arg of [return -code error ...] instead of 'list element in braces followed by "a" instead of space'. I suspect this is the work of Tcl_TransferResult but I'm not familiar with that part, I'd appreciate help (ipso facto solving 2383005). ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 21:47 Message: Ah, OK. Just noticed that [return -foo bar something] just populates the dict with key -foo and value bar. I had wrongly assumed that only the meaningful ones were passed, erroring on others. Anyway I accept the argument of symmetry with errorinfo. Will shortly upload an update including the r/w option. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 18:52 Message: um, that's novel. :) I might be convinced to make this one special, but in that case I don't think the right thing to do with [return -errorstack] is to just let it silently fail. If we are to disallow it, raise an error. I was wondering myself about whether [info errostack] would be sufficient. The issue appears to come down to whether or not the value of -errorstack ought to be considered part of the "state" of the interp -- those values saved and restored by Tcl_*InterpState() and cable to be [catch]-ed and re-raised by [return -options]. Since you call -errorstack a sister of -errorinfo, my first assumption is that it is part of that state, and needs to be part of that save/restore capability, and for that reason needs to be writable via the [return] command. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 18:46 Message: No, -errorstack is just a readonly optsDict member. Even Joe, who asked for it in the first place, didn't ask for a [return -errorstack]. Personally I believe(d) that restricting ourselves to [info/interp errorstack] is(was) even better, but I yielded. Question1: do you think that a read-only optsDict member is out of question ? Question2: where's your preference between: (a) a read-write opt (b) no opt, just [info/interp errorstack] ? ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:50 Message: TclProcessReturn() does not appear to have anything in it to pull a -errorstack value out of the options dict to be stored in the iPtr->errorstack field. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:03 Message: Need to examine whether Tcl_SaveInterpState and friends need to give the -errorstack dict entry any special treatment like errorInfo and errorCode receive, or whether it's fully covered by the returnOpts dict. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:01 Message: -errorstack is like -errorcode in that it wants a list argument. This patch suffers from the same bug as 2383005. Both bugs should be fixed. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 01:59 Message: Patch re-updated to HEAD, and now includes two updates suggested by dgp: (a) restriction of -errorstack dict option to TCL_ERROR cases (b) simplification of the internal [lappend] used ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-02-08 11:08 Message: Patch updated to HEAD. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-11-09 14:26 Message: Added documentatoin in catch.n and info.n. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-23 03:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 18:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 10:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 02:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-29 01:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2010-03-24 15:55:24
|
Patches item #2868499, was opened at 2009-09-28 01:57 Message generated for change (Comment added) made by ferrieux You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 9 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: Don Porter (dgp) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-24 16:55 Message: Attaching patch displaying the uplevel slots as {uplevel $relativelevel}. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-23 22:25 Message: Thanks to Miguel for the hint: varFramePtr != framePtr is the simple check for [uplevel] spurious echoes. Patch updated. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-19 00:08 Message: Patch updated to include the cleaner MergeRetOpts-based check for listness of -errorstack values, and a test case. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 23:57 Message: Let's handle that tiny issue in the bug 2383005 itself. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 23:39 Message: Attached patch doing as promised, [return -errorstack], and a new test case checking that this affects [info errorstack] on subsequent [catch] as expected. Note that it also includes the fix for 2383005. Note however, that in both cases if a non-list like "{}a" is passed to [return -errorstack/errorcode], the resulting error message remains the final arg of [return -code error ...] instead of 'list element in braces followed by "a" instead of space'. I suspect this is the work of Tcl_TransferResult but I'm not familiar with that part, I'd appreciate help (ipso facto solving 2383005). ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 21:47 Message: Ah, OK. Just noticed that [return -foo bar something] just populates the dict with key -foo and value bar. I had wrongly assumed that only the meaningful ones were passed, erroring on others. Anyway I accept the argument of symmetry with errorinfo. Will shortly upload an update including the r/w option. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 18:52 Message: um, that's novel. :) I might be convinced to make this one special, but in that case I don't think the right thing to do with [return -errorstack] is to just let it silently fail. If we are to disallow it, raise an error. I was wondering myself about whether [info errostack] would be sufficient. The issue appears to come down to whether or not the value of -errorstack ought to be considered part of the "state" of the interp -- those values saved and restored by Tcl_*InterpState() and cable to be [catch]-ed and re-raised by [return -options]. Since you call -errorstack a sister of -errorinfo, my first assumption is that it is part of that state, and needs to be part of that save/restore capability, and for that reason needs to be writable via the [return] command. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 18:46 Message: No, -errorstack is just a readonly optsDict member. Even Joe, who asked for it in the first place, didn't ask for a [return -errorstack]. Personally I believe(d) that restricting ourselves to [info/interp errorstack] is(was) even better, but I yielded. Question1: do you think that a read-only optsDict member is out of question ? Question2: where's your preference between: (a) a read-write opt (b) no opt, just [info/interp errorstack] ? ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:50 Message: TclProcessReturn() does not appear to have anything in it to pull a -errorstack value out of the options dict to be stored in the iPtr->errorstack field. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:03 Message: Need to examine whether Tcl_SaveInterpState and friends need to give the -errorstack dict entry any special treatment like errorInfo and errorCode receive, or whether it's fully covered by the returnOpts dict. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 15:01 Message: -errorstack is like -errorcode in that it wants a list argument. This patch suffers from the same bug as 2383005. Both bugs should be fixed. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 01:59 Message: Patch re-updated to HEAD, and now includes two updates suggested by dgp: (a) restriction of -errorstack dict option to TCL_ERROR cases (b) simplification of the internal [lappend] used ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-02-08 11:08 Message: Patch updated to HEAD. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-11-09 14:26 Message: Added documentatoin in catch.n and info.n. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 17:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-23 03:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 18:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 10:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 02:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-29 01:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2010-03-24 19:35:06
|
Patches item #2868499, was opened at 2009-09-27 19:57 Message generated for change (Comment added) made by dgp You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 9 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: Don Porter (dgp) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Don Porter (dgp) Date: 2010-03-24 15:35 Message: In the latest patch the uplevel entries don't appear to happen at the toplevel. Contrast: % proc foo {} {uplevel 1 bar} % proc bar {} {error baz} % catch foo m o 1 % dict get $o -errorstack bar foo % % proc wrap {} {foo} % catch wrap m o 1 % dict get $o -errorstack bar {uplevel 1} foo wrap The uplevel entry between bar and foo doesn't get inserted when foo is called from level #0. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-24 11:55 Message: Attaching patch displaying the uplevel slots as {uplevel $relativelevel}. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-23 17:25 Message: Thanks to Miguel for the hint: varFramePtr != framePtr is the simple check for [uplevel] spurious echoes. Patch updated. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-18 19:08 Message: Patch updated to include the cleaner MergeRetOpts-based check for listness of -errorstack values, and a test case. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 18:57 Message: Let's handle that tiny issue in the bug 2383005 itself. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 18:39 Message: Attached patch doing as promised, [return -errorstack], and a new test case checking that this affects [info errorstack] on subsequent [catch] as expected. Note that it also includes the fix for 2383005. Note however, that in both cases if a non-list like "{}a" is passed to [return -errorstack/errorcode], the resulting error message remains the final arg of [return -code error ...] instead of 'list element in braces followed by "a" instead of space'. I suspect this is the work of Tcl_TransferResult but I'm not familiar with that part, I'd appreciate help (ipso facto solving 2383005). ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 16:47 Message: Ah, OK. Just noticed that [return -foo bar something] just populates the dict with key -foo and value bar. I had wrongly assumed that only the meaningful ones were passed, erroring on others. Anyway I accept the argument of symmetry with errorinfo. Will shortly upload an update including the r/w option. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 13:52 Message: um, that's novel. :) I might be convinced to make this one special, but in that case I don't think the right thing to do with [return -errorstack] is to just let it silently fail. If we are to disallow it, raise an error. I was wondering myself about whether [info errostack] would be sufficient. The issue appears to come down to whether or not the value of -errorstack ought to be considered part of the "state" of the interp -- those values saved and restored by Tcl_*InterpState() and cable to be [catch]-ed and re-raised by [return -options]. Since you call -errorstack a sister of -errorinfo, my first assumption is that it is part of that state, and needs to be part of that save/restore capability, and for that reason needs to be writable via the [return] command. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 13:46 Message: No, -errorstack is just a readonly optsDict member. Even Joe, who asked for it in the first place, didn't ask for a [return -errorstack]. Personally I believe(d) that restricting ourselves to [info/interp errorstack] is(was) even better, but I yielded. Question1: do you think that a read-only optsDict member is out of question ? Question2: where's your preference between: (a) a read-write opt (b) no opt, just [info/interp errorstack] ? ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 10:50 Message: TclProcessReturn() does not appear to have anything in it to pull a -errorstack value out of the options dict to be stored in the iPtr->errorstack field. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 10:03 Message: Need to examine whether Tcl_SaveInterpState and friends need to give the -errorstack dict entry any special treatment like errorInfo and errorCode receive, or whether it's fully covered by the returnOpts dict. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 10:01 Message: -errorstack is like -errorcode in that it wants a list argument. This patch suffers from the same bug as 2383005. Both bugs should be fixed. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-16 20:59 Message: Patch re-updated to HEAD, and now includes two updates suggested by dgp: (a) restriction of -errorstack dict option to TCL_ERROR cases (b) simplification of the internal [lappend] used ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-02-08 05:08 Message: Patch updated to HEAD. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-11-09 08:26 Message: Added documentatoin in catch.n and info.n. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 12:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 12:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-22 21:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 12:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 04:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-04 20:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-28 19:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |
From: SourceForge.net <no...@so...> - 2010-03-24 20:22:51
|
Patches item #2868499, was opened at 2009-09-27 19:57 Message generated for change (Comment added) made by dgp You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: None Group: TIP Implementation Status: Open Resolution: None Priority: 9 Private: No Submitted By: Alexandre Ferrieux (ferrieux) Assigned to: Don Porter (dgp) Summary: TIP #348: Substituted errorStack Initial Comment: Here is a crude but functional implementation of TIP #348. The variable ::errorStack, comes to life when defined (which is not the case by default, to avoid any performance hit). While unwinding, it is populated by substituted argslists as described in the TIP. It is automatically reset (to the empty list) whenever ::errorInfo is. (But this leaves it enabled. To disable it, unset it.) (Among crudities: uses ::errorStack instead of ::tcl::errorStack, doesn't pay attention to code style, no test cases. Also, it inserts two fields in the private interp structure, right in the middle, not at the end. ABI hazard, don't forget to 'make clean' after applying ;-) ---------------------------------------------------------------------- >Comment By: Don Porter (dgp) Date: 2010-03-24 16:22 Message: ok, that logic wasn't hard to correct. see new patch. Not a huge deal, but I notice that the constructed uplevel entries always reports the relative level difference, even when it was a command using an absolute level, like [uplevel #0] that caused the branch in the tree of CallFrames. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-24 15:35 Message: In the latest patch the uplevel entries don't appear to happen at the toplevel. Contrast: % proc foo {} {uplevel 1 bar} % proc bar {} {error baz} % catch foo m o 1 % dict get $o -errorstack bar foo % % proc wrap {} {foo} % catch wrap m o 1 % dict get $o -errorstack bar {uplevel 1} foo wrap The uplevel entry between bar and foo doesn't get inserted when foo is called from level #0. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-24 11:55 Message: Attaching patch displaying the uplevel slots as {uplevel $relativelevel}. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-23 17:25 Message: Thanks to Miguel for the hint: varFramePtr != framePtr is the simple check for [uplevel] spurious echoes. Patch updated. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-18 19:08 Message: Patch updated to include the cleaner MergeRetOpts-based check for listness of -errorstack values, and a test case. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 18:57 Message: Let's handle that tiny issue in the bug 2383005 itself. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 18:39 Message: Attached patch doing as promised, [return -errorstack], and a new test case checking that this affects [info errorstack] on subsequent [catch] as expected. Note that it also includes the fix for 2383005. Note however, that in both cases if a non-list like "{}a" is passed to [return -errorstack/errorcode], the resulting error message remains the final arg of [return -code error ...] instead of 'list element in braces followed by "a" instead of space'. I suspect this is the work of Tcl_TransferResult but I'm not familiar with that part, I'd appreciate help (ipso facto solving 2383005). ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 16:47 Message: Ah, OK. Just noticed that [return -foo bar something] just populates the dict with key -foo and value bar. I had wrongly assumed that only the meaningful ones were passed, erroring on others. Anyway I accept the argument of symmetry with errorinfo. Will shortly upload an update including the r/w option. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 13:52 Message: um, that's novel. :) I might be convinced to make this one special, but in that case I don't think the right thing to do with [return -errorstack] is to just let it silently fail. If we are to disallow it, raise an error. I was wondering myself about whether [info errostack] would be sufficient. The issue appears to come down to whether or not the value of -errorstack ought to be considered part of the "state" of the interp -- those values saved and restored by Tcl_*InterpState() and cable to be [catch]-ed and re-raised by [return -options]. Since you call -errorstack a sister of -errorinfo, my first assumption is that it is part of that state, and needs to be part of that save/restore capability, and for that reason needs to be writable via the [return] command. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-17 13:46 Message: No, -errorstack is just a readonly optsDict member. Even Joe, who asked for it in the first place, didn't ask for a [return -errorstack]. Personally I believe(d) that restricting ourselves to [info/interp errorstack] is(was) even better, but I yielded. Question1: do you think that a read-only optsDict member is out of question ? Question2: where's your preference between: (a) a read-write opt (b) no opt, just [info/interp errorstack] ? ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 10:50 Message: TclProcessReturn() does not appear to have anything in it to pull a -errorstack value out of the options dict to be stored in the iPtr->errorstack field. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 10:03 Message: Need to examine whether Tcl_SaveInterpState and friends need to give the -errorstack dict entry any special treatment like errorInfo and errorCode receive, or whether it's fully covered by the returnOpts dict. ---------------------------------------------------------------------- Comment By: Don Porter (dgp) Date: 2010-03-17 10:01 Message: -errorstack is like -errorcode in that it wants a list argument. This patch suffers from the same bug as 2383005. Both bugs should be fixed. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-03-16 20:59 Message: Patch re-updated to HEAD, and now includes two updates suggested by dgp: (a) restriction of -errorstack dict option to TCL_ERROR cases (b) simplification of the internal [lappend] used ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2010-02-08 05:08 Message: Patch updated to HEAD. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-11-09 08:26 Message: Added documentatoin in catch.n and info.n. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 12:37 Message: Test suite now fixed. Thanks to -match glob :) ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-31 12:01 Message: Patch now restricted as per Joe's recommendations on tclcore: - always on - non-flat list - with options dict Test suite now needs fixes wherever the options dict was checked in extenso... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-22 21:03 Message: Extended patch adds bit value 4 as "flat list", ie errorstack is built as 2 foo bar 1 baz 2 gnu gnats instead of {foo bar} baz {gnu gnats} Hence: use=0 : pristine use=1 : info errorstack use=2 : + dict use=5 : 1 + flatlist use=6 : 2 + flatlist Timings below: Case: Ten-fold catch ladder use=0 -> 101.3854 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 106.2653 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 106.8439 microseconds per iteration Case: Ten-fold catch ladder use=5 -> 103.5229 microseconds per iteration Case: Ten-fold catch ladder use=6 -> 103.7669 microseconds per iteration Case: Single Catch with opt dict use=0 -> 25.814 microseconds per iteration Case: Single Catch with opt dict use=1 -> 26.2905 microseconds per iteration Case: Single Catch with opt dict use=2 -> 27.0002 microseconds per iteration Case: Single Catch with opt dict use=5 -> 26.0665 microseconds per iteration Case: Single Catch with opt dict use=6 -> 26.783 microseconds per iteration Conclusion: while the gain for a tight catch loop is negligible, for a ten-fold catch ladder building a long errorstack it is substantial: the flatlist roughly divides the overhead by three. However, the flatlist is a bit less convenient for the programmer. It could be postprocessed into a nested list in [info errorstack] but not int the options dict... ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-20 12:17 Message: Attaching a new patch, errorstack2.patch, fulfilling Joe's request of [info errostack ?interp?] and [dict get $d -errostack]. I left the ::tcl::useErrorStack control variable for perf measurements: 0 --> pristine HEAD 1 --> just [info errorstack] 2 ---> adds options dict entry -errorstack Note the implementation still uses ckalloc-based Tcl_NewListObj for argslist, pending proof that optimization is needed. Here are the figures: Case: Ten-fold catch ladder use=0 -> 74.7924 microseconds per iteration Case: Ten-fold catch ladder use=1 -> 76.7888 microseconds per iteration Case: Ten-fold catch ladder use=2 -> 77.1977 microseconds per iteration Case: Single Catch with opt dict use=0 -> 19.2613 microseconds per iteration Case: Single Catch with opt dict use=1 -> 19.7608 microseconds per iteration Case: Single Catch with opt dict use=2 -> 20.2815 microseconds per iteration with code: for {set i 1} {$i<10} {incr i} { proc f$i x "f[expr {$i+1}] \$x" } proc f10 x {error F10:$x} proc boo {} {error BOO} proc catchloop {} { for {set i 0} {$i<100000} {incr i} { if {[catch boo m d]} continue } } foreach {mm ss} { "Ten-fold catch ladder" {catch {f1 12}} "Single Catch with opt dict" {catch boo m d} } { foreach v {0 1 2} { set ::tcl::useErrorStack $v puts "Case: $mm use=$v -> [time $ss 10000]" } } ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-05 04:12 Message: Complete with test cases now. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-10-04 20:46 Message: Mostly done. - now the var is ::tcl::errorStack and the flag is ::tcl::useErrorStack - zero overhead when ::tcl::useErrorStack is 0 (default) - uses a read trace to postpone var machinery until real use - uses an optimized in-place lappend/reset to keep the list intrep as much as possible (just as fast as the linked list approach IMO) TBD: test cases. ---------------------------------------------------------------------- Comment By: Alexandre Ferrieux (ferrieux) Date: 2009-09-28 19:00 Message: First slight improvement: explicitly skip iPtr->rootFramePtr, like in [info level $n], since the root frame will always have argc==0. This removes the parasitic {} always found at the end of ::errorStack, and also an extra one generated by [tailcall] and [coroutine]. Next improvements planned: (1) make the on/off switch more efficient by using a linked boolean var rather than the existence of ::errorStack which costs a hash lookup when negative. (2) make the list building slightly more efficient by using a backbone of Tcl_Obj as Cons'es (linked list), and turning it into a Tcl list only in a read trace attached to ::errorStack (instead of directly lappending as is currently the case. This construction is wasted in caught, expected exception handling where the errorStack is not used). (3) proper ::tcl namespace + test cases. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=310894&aid=2868499&group_id=10894 |