cookbook:measuring

This shows you the differences between two versions of the page.

cookbook:measuring [Monday, 04 December 2006 : 11:20:17] 127.0.0.1 external edit |
cookbook:measuring [Thursday, 12 February 2009 : 09:49:47] (current) hvrooy |
||
---|---|---|---|

Line 1: | Line 1: | ||

+ | ====== Measuring performance====== | ||

+ | When executing a simulation experiment we are interested in performance indicators. | ||

+ | To calculate these performance indicators we introduce seperate processes in which the calculation takes place. Such a process can be considered to be an oscilloscope. | ||

+ | By instantiating a number of these processes we can calculate various performance indicators. | ||

+ | The different processes are identified by their name. | ||

+ | |||

+ | We present a process that calculates the mean and the coefficient of variation of the inter-arrival time. We introduce a process for calculating the utilization of a machine. We give a process that calculates the time averaged content of a buffer. | ||

+ | For an explanation of the used iterative formulas we refer to {{:chi:learningchi10_4.pdf|Learning chi1.0}}. | ||

+ | |||

+ | ===== Mean and coefficient of variation of inter-arrival times ===== | ||

+ | |||

+ | In models sometimes we are interested in the mean inter-arrival time and the coefficient of the inter-arrival time. | ||

+ | The following piece of code illustrates this. | ||

+ | We have generator ''G'': | ||

+ | <code chi> | ||

+ | proc G(chan a!: item, val ta: real) = | ||

+ | |[ var u: -> real = exponential(ta), t: real | ||

+ | , id: nat = 1 | ||

+ | :: *( a!(id,time); t:= sample u; delay t; id:= id + 1 ) | ||

+ | ]| | ||

+ | </code> | ||

+ | This generator sends every ''sample u'' time units (assuming that ''a!(id,time)'' is always possible) an item to another process, say exit process ''X''. | ||

+ | This process can be described by: | ||

+ | <code chi> | ||

+ | proc X(chan a?: item) = | ||

+ | |[ var x: item | ||

+ | :: * a?x | ||

+ | ]| | ||

+ | </code> | ||

+ | |||

+ | We are interested in the inter-arrival time in process ''X''. For that purpose we modify process ''X'': | ||

+ | <code chi> | ||

+ | proc X(chan a?: item, p!: real) = | ||

+ | |[ var x: item, t: real = 0.0 | ||

+ | :: *( a?x; p!time - t; t:= time ) | ||

+ | ]| | ||

+ | </code> | ||

+ | We determine the inter-arrival time in process ''X''. We send this value via channel ''p'' to another process, say process ''A''. In process ''A'' we calculate mean ''m'' and variance ''v''. We introduce a parameter ''n'' denoting that after receiving ''n'' values the mean and the coefficient of variation are printed (By using the piping construction of Linux we also can send the result to a file). Coefficient of variation ''c'' is defined by: ''c = sqrt(v) / m''. We have for process ''A'': | ||

+ | <code chi> | ||

+ | proc A(val title: string, chan p?: real, val n: nat) = | ||

+ | |[ var i: nat = 0, m: real = 0.0, v: real = 0.0 | ||

+ | , x: real | ||

+ | :: *( p?x; i:= i + 1 | ||

+ | ; ( i > 1 -> v:= (i - 2) / (i - 1) * v + (x - m)^2 / i | ||

+ | | i <= 1 -> skip | ||

+ | ) | ||

+ | ; m:= (i - 1) / i * m + x / i | ||

+ | ; ( i mod n > 0 -> skip | ||

+ | | i mod n = 0 | ||

+ | -> !! time, "\t", title, "\t", i | ||

+ | , "\t", m, "\t", sqrt(v) / m, "\n" | ||

+ | ) | ||

+ | ) | ||

+ | ]| | ||

+ | </code> | ||

+ | In variable ''m'' we store the average value of the received ''x''-values, in variable ''v'' we store the variance of the received ''x''-values. After ''n'' receipts of variable ''x'' we print the current time, the title of the process (to distinguish the various processes) the mean of ''x'' and the coefficient of variation ''c''. | ||

+ | |||

+ | Eventually we combine the processes into process ''S'': | ||

+ | <code chi> | ||

+ | proc S() = | ||

+ | |[ chan a: item, b: real | ||

+ | :: G(a) || X(a,b) || A("mc",b,100) | ||

+ | ]| | ||

+ | </code> | ||

+ | This process calculates the mean and the coefficient of variation of the inter-arrival times in process ''X'' (or the inter-departure times in process ''G''). These values are printed after the reception of 100 items in process ''X''. | ||

+ | |||

+ | |||

+ | |||

+ | ===== Mean utilization of a machine ===== | ||

+ | |||

+ | We define machine ''M''. The machine processes items with two processing times of 1.0 and 5.0 time units. The time is determined by a distribution. We assume a ''bernoulli'' distribution with a probability of 0.5. This implies that 50% of the items have a processing time of 1.0 time units and 50% of the items have a procesing time of 5.0 time units. | ||

+ | The specification of process ''M'' is: | ||

+ | <code chi> | ||

+ | proc M(chan a?,b!: item) = | ||

+ | |[ var u: -> bool = bernouilli(0.5) | ||

+ | , x: item, p: bool | ||

+ | :: *( a?x; p:= sample u | ||

+ | ; ( p -> delay 1.0 | ||

+ | | not p -> delay 5.0 | ||

+ | ) | ||

+ | ; b!x | ||

+ | ) | ||

+ | ]| | ||

+ | </code> | ||

+ | We are interested in the mean utilization of the machine. For that purpose we modify machine ''M''. After receiving an item we send a message ''false'' to an oscilloscope. Later we define this oscilloscope. After sending an item we send the message ''true'' to the oscilloscope: | ||

+ | <code chi> | ||

+ | proc M(chan a?,b!: item, p!: bool) = | ||

+ | |[ var u: -> bool = bernouilli(0.5) | ||

+ | , x: item, pr: bool | ||

+ | :: *( a?x; p!false; pr:= sample u | ||

+ | ; ( pr -> delay 1.0 | ||

+ | | not pr -> delay 5.0 | ||

+ | ) | ||

+ | ; b!x; p!true | ||

+ | ) | ||

+ | ]| | ||

+ | </code> | ||

+ | We introduce oscilloscope ''U'': | ||

+ | <code chi> | ||

+ | proc U(val title: string, chan p?: bool, val n: nat) = | ||

+ | |[ var i: nat = 0, oldt: real = 0.0, u: real | ||

+ | :: *( p?b; i:= i + 1 | ||

+ | ; ( b -> u:= oldt / time * u | ||

+ | | not b -> u:= oldt / time * u + (time - oldt) / time | ||

+ | ) | ||

+ | ; oldt:= time | ||

+ | ; ( i mod n > 0 -> skip | ||

+ | | i mod n = 0 | ||

+ | -> !! time, "\t", title, "\t", i | ||

+ | , "\t", u, "\n" | ||

+ | ) | ||

+ | ) | ||

+ | ]| | ||

+ | </code> | ||

+ | We define process ''MU'' consisting of machine ''M'' and oscilloscope ''U'': | ||

+ | <code chi> | ||

+ | proc MU(var title: string, chan a?,b!; item, val n: nat) = | ||

+ | |[ chan p: bool :: M(a,b,p) || U(title,p,n) ]| | ||

+ | </code> | ||

+ | |||

+ | ===== Time averaged content of a buffer ===== | ||

+ | |||

+ | We define an item: | ||

+ | <code chi> | ||

+ | type item = ? | ||

+ | </code> | ||

+ | |||

+ | We define generator ''G''. The generator produces items, according to an exponential distribution with an averaged inter arrival time of 2.0 time units. These items are sent to buffer process ''B''. | ||

+ | <code chi> | ||

+ | proc G(chan a!: item) = | ||

+ | |[ var i: nat = 1, u: -> real = exponential(2.0), t: real | ||

+ | :: *( a!(i,time); t:= sample u; delay t; i:= i + 1 ) | ||

+ | ]| | ||

+ | </code> | ||

+ | |||

+ | The buffer process is modeled by: | ||

+ | <code chi> | ||

+ | proc B(chan a?,b!: item) = | ||

+ | |[ var xs: [item] = [], x: item | ||

+ | :: *( a?x; xs:+ xs ++ [ x ] | ||

+ | | len(xs) > 0 -> b!hd(xs); xs:= tl(xs) | ||

+ | ) | ||

+ | ]| | ||

+ | </code> | ||

+ | |||

+ | A machine processes the items. We assume an exponential distributed processing time of 1.5 time units. | ||

+ | We define machine ''M'' by: | ||

+ | <code chi> | ||

+ | proc M(chan a?,b!: item) = | ||

+ | |[ var u: -> real = exponential(1.5), t: real, x: item | ||

+ | :: *( a?x; t:= sample u; delay t; b!x ) | ||

+ | ]| | ||

+ | </code> | ||

+ | |||

+ | Items leave the system via process ''E'', the exit process: | ||

+ | <code chi> | ||

+ | proc E(chan a?: item) = | ||

+ | |[ x: item :: * a?x ]| | ||

+ | </code> | ||

+ | We are interested in the timed average content in the buffer. For that purpose we modify buffer ''B''. | ||

+ | After receiving or sending an item we send the length of list ''xs'' to an oscilloscope. Buffer ''B'' becomes: | ||

+ | <code chi> | ||

+ | proc B(chan a?,b!: item, c!: nat) = | ||

+ | |[ var xs: [item] = [], x: item | ||

+ | :: *( ( a?x; xs:= xs ++ [ x ] | ||

+ | | len(xs) > 0 -> b!hd(xs); xs:= tl(xs) | ||

+ | ) | ||

+ | ; c!len(xs) | ||

+ | ) | ||

+ | ]| | ||

+ | </code> | ||

+ | If the length of the list in the buffer has been changed we notify the oscilloscope. | ||

+ | We introduce oscilloscope ''V'': | ||

+ | <code chi> | ||

+ | proc V(val title: string, chan p?: nat, val n: nat) = | ||

+ | |[ var i: nat = 0, oldt: real = 0.0 | ||

+ | , wmax: nat = 0, wold: real = 0.0, w,wav: real | ||

+ | :: *( p?w; i:= i + 1 | ||

+ | ; ( w <= wmax -> skip | w > wmax -> wmax:= w ) | ||

+ | ; wav:= told / time * wav + (time - told) / time * wav | ||

+ | ; oldt:= time | ||

+ | ; ( i mod n > 0 -> skip | ||

+ | | i mod n = 0 | ||

+ | -> !! time, "\t", title, "\t", i, "\t", wmax | ||

+ | , "\t", w, "\t", wav, "\n" | ||

+ | ) | ||

+ | ) | ||

+ | ]| | ||

+ | </code> | ||

+ | We define process ''BV'' consisting of buffer ''B'' and oscilloscope ''V'': | ||

+ | <code chi> | ||

+ | proc BV(var title: string, chan a?,b!; item, val n: nat) = | ||

+ | |[ chan p: nat :: M(a,b,p) || V(title,p,n) ]| | ||

+ | </code> |

cookbook/measuring.txt · Last modified: Thursday, 12 February 2009 : 09:49:47 by hvrooy

Except where otherwise noted, content on this wiki is licensed under the following license: CC Attribution-Noncommercial-Share Alike 4.0 International