Changes

=Performance Functions=

==prof:timetrack== {{Mark|Updated with Version 9.0:}} {{Code|$cache}} argument removed.

|{{Func|prof:timetrack|$expr expression as item()|item()*}}<br />{{Func|prof:timetrack|$expr expression as item(), $label options as xs:stringmap(*)?|item()*}}

|Measures the execution time needed to evaluate and memory consumption required for evaluating the specified {{Code|$exprexpression}} and outputs returns a string to standard error or, if map with the GUI is used, to the Info Viewresults.<br/>An optional The following {{Code|$labeloptions}} are available:* {{Code|time}}: Include execution time in result as {{Code|xs:decimal}} (unit: milliseconds; default: true).* {{Code|memory}}: Include memory consumption in result as {{Code|xs:integer}} (unit: bytes; default: false).* {{Code|value}} may be specified to tag the profiling : Include value in result(default: true). Helpful notes:* If you are not interested in some of the returned results, you should disable them to save time and memory.* Profiling might change the execution behavior of your code: An expression that might be executed iteratively will be cached by the profiling function.* If a value has a compact internal representation, evaluation time memory consumption will be very low, even if the serialized result may consume much more memory.* Please note that memory profiling is only approximative, so it may take a long time can be quite misleading. If the memory option is enabled, main-memory will be garbage-collected before and after evaluation to iterate through all resultsimprove the quality of the measurement.

* {{Code|Return a human-readable representation of the memory consumption caused by fetching an XML document (<code>fetch:xml</code> is used, as <code>fn:doc</code> may already be evaluated at compilation time):<pre class="brush:xquery">prof:timetrack(fetch:xml('factbook.xml'))?memory=> prof:sleephuman(1000)</pre>* The function call <code>prof:track((1 to 1000000)[. mod 2 = 0], map { 'time': false()}} outputs )</code> will return something similar to :<pre class="brush:xquery">map {{Code|1000 "memory": 21548400, "value": (2, 4, 6, 8, 10, ...99 ms})}.</pre>

==prof:memorytime== {{Mark|Updated with Version 9.0:}} Renamed (old name: <code>prof:mem</code>); {{Code|$cache}} argument removed.

|{{Func|prof:memorytime|$expr as item()|item()*}}<br/>{{Func|prof:memorytime|$expr as item(), $label as xs:string|item()*}}

|Measures the memory allocated by evaluating time needed to evaluate {{Code|$expr}} and outputs a string to standard error or, if the GUI is used, to the Info View. An optional {{Code|$label}} may be specified to tag the profiling result. Helpful notes:* See {{Function|Profiling might change the behavior of your code|prof: An expression that might be executed iteratively will be cached by the profiling function.* If a value has a compact internal representation, memory consumption will be very low, even if the serialized result may consume much more memory.* In Java, memory profiling can only be approximative: To improve the measurement, main-memory will be garbage-collected before and after evaluationtrack}} for further notes.

* {{Code|prof:memorytime(prof:sleep(1 to 1000001000) ! <a/>)}} will output outputs something similar to {{Code|5620 kB1000.99 ms}}.

==prof:trackmemory== {{Mark|Introduced with Version 9.0:}}

|{{Func|prof:trackmemory|$expr as item()|item()*}}<br/>{{Func|prof:trackmemory|$expr as item(), $options label as map(*)xs:string|item()*}}

|Measures the execution time and memory consumption required for allocated by evaluating the specified {{Code|$expressionexpr}} and returns outputs a map with string to standard error or, if the GUI is used, to the resultsInfo View. The following An optional {{Code|$optionslabel}} are available:* {{Code|memory}}: Enables time may be specified to tag the profiling (default: true)result.* See {{CodeFunction|Profiling|time}}prof: Enables memory profiling (default: true).* {{Code|valuetrack}}: Returns the value (default: true).Helpful for further notes:* Profiling might change the behavior of your code: An expression that might be executed iteratively will be cached by the profiling function.* If a value has a compact internal representation, memory consumption will be very low, even if the serialized result may consume much more memory.* In Java, memory profiling can only be approximative: To improve the measurement, and if the memory option is enabled, main-memory will be garbage-collected before and after evaluation. If you are not interested in the memory consumption, it is advisable to disable this option.

|The function call <code>* {{Code|prof:trackmemory((1 to 1000000)[. mod 2 = 0]100000)! <a/code> )}} will return output something similar to:<pre class="brush:xquery">map { "memory": 41548400, "time": 34{Code|5620 kB}}.99, "value": (2, 4, 6, 8, 10, ...)}</pre>

==prof:sleepcurrent-ms==

|{{Func|prof:sleepcurrent-ms||$ms as xs:integer|empty-sequence()}}<br />

|Sleeps for Returns the specified number of milliseconds passed since 1970/01/01 UTC. The granularity of the value depends on the underlying operating system and may be larger. For example, many operating systems measure time in units of tens of milliseconds.

|The In contrast to {{Code|fn:current-time()}}, the function is ''non-deterministic'': and returns different values every time it is called. Its evaluation order will be preserved by the compiler.|-| '''Examples'''|* {{Code|convert:integer-to-dateTime(prof:current-ms())}} returns the current miliseconds in the {{Code|xs:dateTime}} format.

==prof:humancurrent-ns==

|{{Func|prof:humancurrent-ns||$number as xs:integer|xs:string}}<br />

|Returns a human-readable representation the current value of the specified most precise available system timer in nanoseconds.|-| '''Properties'''|In contrast to {{Code|$numberfn:current-time()}}, the function is ''non-deterministic'' and returns different values every time it is called. Its evaluation order will be preserved by the compiler.

| '''ExampleExamples'''|Measures the time of an expression:<pre class="brush:xquery">let $ns1 := prof:current-ns()return ( (: process to measure :) (1 to 1000000)[. = 0],* {{Code| let $ns2 := prof:humancurrent-ns() let $ms := (16384(($ns2 - $ns1)}} returns {{Codeidiv 10000) div 100) return $ms |16K}}.| ' ms')</pre>

|{{Func|prof:dump|$expr as item()*|empty-sequence()}}<br />{{Func|prof:dump|$expr as item()*, $label as xs:string|empty-sequence()}}<br />

|Prints a list of all current local and global variable assignments to standard error or, if the GUI is used, to the Info View.<br />As every query is optimized before being evaluated, not all of the original variables may be visible in the output. Moreover, many variables of function calls will disappear because functions are inlined. Function inlining can be turned off by setting the [[Options#INLINELIMIT{{Option|INLINELIMIT]] option }} to <code>0</code>.

* {{Code|for $x in 1 to 2 return ($x, prof:variables())}} will dump the values of <code>$x</code> to standard error.

==prof:current-mstype==

|{{Func|prof:current-mstype|$expr as item()*|xs:integeritem()*}}<br />

|Returns the number of milliseconds passed since 1970/01/01 UTC. The granularity Similar to {{Code|fn:trace($expr, $msg)}}, but instead of a user-defined message, it emits the value depends on the underlying operating system compile-time type and may be larger. For example, many operating systems measure time in units of tens estimated result size of millisecondsits argument.|} ==prof:gc== {| width='100%'

| width='120'| 'Properties''Signatures'''|In contrast to {{CodeFunc|fnprof:currentgc||empty-timesequence()}}, the function is ''non<br/>{{Func|prof:gc|$count as xs:integer|empty-deterministic'' and returns different values every time it is called. Its evaluation order will be preserved by the compiler.sequence()}}

| '''ExamplesSummary'''|* Enforces Java garbage collection. If no {{Code|convert:integer-to-dateTime(prof:current-ms())$count}} returns the current miliseconds is supplied, garbage will be collected once. Please note that this function should only be used for debugging purposes; in productive code, it is best to trust the {{Code|xs:dateTime}} formatgarbage collecting strategies of Java.

==prof:current-nsruntime==

|{{Func|prof:current-nsruntime|$name of xs:string|xs:integer}}<br />

|Returns the current value of the most precise specified runtime {{Code|$option}}. The following options exist:* {{Code|max}}: Maximum memory that the Java virtual machine will attempt to use.* {{Code|total}}: Total memory in the Java virtual machine (varies over time).* {{Code|used}}: Currently used memory (varies over time, will shrink after garbage collection).* {{Code|processors}}: number of processors available system timer in nanosecondsto the Java virtual machine.

| '''Properties'''|In contrast to {{Code|fn:current-time()option}}, the function is ''non-deterministic'' and returns different values every time it |The specified option is called. Its evaluation order will be preserved by the compilerunknown.

| Measures the time of an expression:* <pre class="brush:xquery"code>let $ns1 := prof:current-nsgc(3)return ( (: process to measure :) (1 to 1000000)[. = 0], let $ns2 := prof:current-nshuman() let $ms prof:= (runtime(($ns2 - $ns1) idiv 10000) div 100) return $ms || ' msused'))</precode>performs some garbage collection and returns the currently used amount of memory in a user-friendly format.

==prof:typesleep== {| width='100%'|-| width='120' | '''Signatures'''|{{Func|prof:sleep|$ms as xs:integer|empty-sequence()}}<br />|-| '''Summary'''|Sleeps for the specified number of milliseconds.|-| '''Properties'''|The function is ''non-deterministic'': evaluation order will be preserved by the compiler.|} ==prof:human==

|{{Func|prof:typehuman|$expr number as item()*xs:integer|item()*xs:string}}

|Similar to Returns a human-readable representation of the specified {{Code|$number}}.|-| '''Example'''|* {{Code|fnprof:tracehuman($expr, $msg16384)}}, but instead of a userreturns {{Code|16K}}.|} =Errors= {| class="wikitable" width="100%"! width="110"|Code|Description|-defined message, it emits the compile-time type and estimated result size of its argument|{{Code|option}}|The specified option is unknown.

* Updated: renamed prof:mem to [[#prof:memory|prof:memory]], [[#prof:time|prof:time]]: <code>$cache</code> argument removed