We considered and evaluated several scheduling algorithms that combined different classi.cation schemes and policies, and in this section we present those that showed the best performance and were also the simplest to implement.

we evaluate two algorithms based on the Miss Rate classi.cation schemes, because the miss rate is very easy to obtain online via hardware performance counters.


In contrast, Shapley value-based energy accounting takes a temporal view of energy consumption.

it views energy consumption as resulting from a collection of time intervals, or games.


To solve this problem, we employ mappings as done in the reflexion model [12].

we map the abstract components to source code for both products from the domain point of view.


INTRODUCTION As computation and communication technologies advance, new technologies o.er the potential for capturing dynamic geographic phenomena at increasingly .ne spatial and temporal granularities.

geosensor networks (GSN, a wireless network of tiny, sensor-enabled computing devices, called sensor nodes [11]) are driving the investigation of new algorithms to spatial data capture and computation.


Finally, when a new record (p35,mc) is added to STreatments, the result of QS will change.


ICFGAA is context insensitive in that data.ow analysis values can .ow along unrealizable control paths.

values can .ow into a procedure along the call edge of one call site and .ow out of the procedure along the return edge of another call site.


For instance, a unit increase in the Process Maturity measure would results in the decrease of the estimated defect count associated with a software component by a factor of 0.22.

the model suggest that going from an average of 3 in Process Maturity across the locations that worked on a component to an average of 4 could result in a estimated 4.5 times reduction of the number of defects found in system integration associated with that software component.


2.4 Algorithms After reading the previous sections there are likely questions that remain.

we foresee the following possibilities:  The function-class ToString in Figure 2 looks like it follows directly from the CD in Figure 1.


Placing the header next to the object itself also degrades data locality, because the header is only accessed by the allocator and not by the application accessing the object [9].

the header and the object have different access patterns and frequencies and, if put in the same cache line, may lower cache line utilization.


Thielecke (2003) shows how to use a type-and-effect system to reason about how expressions treat their continuations.

he gives a continuation-passing style transform where continuations that will be used linearly are given a linear type.


Thurimella and his colleagues [18] already suggested applying QOC for making decisions on commonalities and variations.

they proposed issue-based variability management (IVM) for enabling rationale enhancements for identifying, instantiating and changing variability.


In sum, the corresponding tile dimension is given by Si = (si + di 1 u)/wi , (14) where u is a normalized version of t that ensures that the starting positions of the tiles in the spatial direction are the same for all time tiles and for both phases.

we set u = (t + h + 1) mod (2h + 2) for phase 0 and (15) u = t mod (2h + 2) for phase 1.


Although add and contains do not commute, contains is not a strongly non-commutative method.

add in.uences the result of contains,but contains does not in.uence the result of add.


va ::: ValidVAddr / {do m; execContext pm c; getPage pm va} ::: Returns {Just PageInfo { physPage = fst pa, writable = True, dirty = True, accessed = True}} |} assert All pa, pm, c, m. m ::: Changed pa pm c ==> m ::: Dirty pa pm c Note that the last assertion only partially speci.es how dirty and access bits behave; it gives suf.cient, but not necessary conditions for them to be set after execution.

we do not specify that access bits should be set when a user process reads from a page.


This setup allowed for a close (post mortem) examination of the impact that code coverage analysis and visualization had exerted on the development process and especially on automated tests.

the following four questions related to the introduction of code coverage analysis and visualization tools will be addressed: (1) What was the impact in terms of code coverage of the automated tests?


The .rst aims to eliminate an extra penalty introduced by Intel processors [16] when multiple data items in an AVX register are reduced to a single value, using an SSE instruction.

a vzeroupper instruction is inserted after the reduction operation to prevent the hardware from recovering the upper bits of the AVX register, thus saving wasted clock cycles.


This method, which is called SOVA Semantic and Ontological Variability Analysis and supported by a tool [12], extracts behaviors from textual descriptions of (functional) requirements.

it automatically identifies the initial state of a system before the behavior occurs, the external events that trigger the behavior, and the final state of the system after the behavior occurs.


Time As the above on-line property implies, the selforganising coordination process is strongly-dependent on time as any other self-organising process in nature [27].


Our study shows that this type of modeling adds to our understanding of the architecture and the decisions that led to it.

we illustrate each of the aforementioned uses of explicitly modeled assumptions.


The current model@runtime tools have been implemented regardless of the speci.c characteristics and constraints of a Cyber Physical System.

the network topology and the resource constraint of the nodes forming the distributed system have not been taken into consideration.


User requests and garbage collection activities use the same cache update policy because they both look up the mapping cache and can cause cache misses.

the mapping cache loads the mapping pairs fetched during garbage collection (regardless of the workload type).


We then prove that projection to subclasses preserves typing.

if a type t is well formed in an environment from class c, then the projection of t ' onto the subclass c is well-formed in the environment ' as de.ned in the subclass c .


We also note that we would expect the data from this empirical study to support the mechanics of each refactoring stated in [9].

if refactoring A is said to use refactoring B as part of its since when we move a method, we also tend to move a field.


Accordingly an action is fair, if for each of its sub-actions there is at least one scenario in which the sub-action is actually executed.

the complex action contains no dead code which is never executed during runtime.


This result might be due to the fact that subjects in the second and third institutions had more time to perform their tasks.

they did not project Business and, so, they had extra time to concentrate on Persistence.


Most importantly, we show in Proposition 7 that the DETERMIN algorithm is correct.

for any inferred deterministic speci.cation (PreR, PostR) for executions R of procedure P : 1.


Testing of a family member is simpler than testing a single program because the portion of the test plan and test cases that were developed in the domain testing stage can be reused.

the tests performed in the domain testing stage do not need to repeat.


Consequently, it is relatively easy (i.e., less reasoning is needed) for an attacker to guess how a system works and to estimate its optimal strategy (i.e., no cheating, if a pre-trusted peer is involved in a transaction; otherwise, behave depending on each user s behavior).

the attacker can save its time in satisfying a given pro.t goal G with a small number of reasoning steps.


Intuitively, the latter criterion means that a system should work as well as possible in scenarios in which the assumptions about its environment are violated.

the system shall degrade gracefully, and all safety-relevant properties of the system should be ful.lled whenever possible.


Therefore, the existence of massively scattering commits cannot be neglected.

such commits may have a major impact when considered in cochange graphs, due to the very large deviation between the number of classes changed by them and by the remaining commits in the system.


Second, we found that RMT techniques can incur a higher performance penalty for single-processor devices than previous studies on AR-SMT and SRT processors have demonstrated.

we find that the size of the store queue for the leading thread has a significant impact on the performance of single-processor RMT devices.


Each of these tasks requires service descriptions for the nodes of the system.

the nodes must somehow publish abstracts of their capabilities so that clients (end users, tools, other service nodes, and administrators) can understand what each o.ers.


For simplicity we omit the semantics of instructions that do not access shared memory (register operations, branches) and leave expression evaluation implicit.

l(r) is extended to the evaluation of complex expressions r. Such a complex expression may only depend on local variables expression evaluation may not cause a memory access.


In this way, modularity contributes to improve productivity both during initial development and maintenance phases.

well-modularized systems are easier to maintain and evolve, because their modules can be understood and changed independently from each other.


For example, we want to test the transitions caused by connection establishment and closing, including obscure cases such as simultaneous closing1.

we want to generate sequencesofeventsthatmaketheTCP implementationmovethrough all possible statesinthe state machineinall possibleways.Weneed to create different sequences to get to state ESTABLISHED and different sequencestogetto CLOSEDagain.Atypical connection establishment would follow Figure 2: 1.


The preconditions of all individual actions are jointly logi- cally consistent in s. That is, the conjunction of all atomic formulae in precondition lists evaluates to TRUE in s.  The postconditions are jointly consistent in s. That is, there are no two actions such that the first one brings about a ground atom while the second action brings about the nega- tion of that atom.

action effects do not con-  flict with one another.


These policies allow middleware developers to use reflection to specify configurations in a systematic way.

we have described the DSM-based Genie toolkit and its role in the automated generation of configuration policies for the GridKit middleware.


either allocate in the same stack frame as the caller if the caller was marked @StackAllocation, or in whatever memory area its caller was allocating in if it was not marked @StackAllocation.

if a method without either annotation is called from a method marked @StackAllocation, then this method will allocate in the memory area determined by the Real Time Java library.


The requirement to support multiple execution platforms results in unique challenges to the design of cross-language interoperability.

we discovered that a single top exception type that covers all exception types from source and all target languages is needed as a native type of the source language for portable exception handling.


In this paper, we combine air pollution and human energy expenditure data to give individuals real-time personal air pollution exposure estimates.

this paper describes our experiences with developing a personal air pollution exposure estimation system utilising participatory air pollution monitoring system and energy expenditure data collected from wearable activity sensors.


start true goal ( booksAvailableInStock and orderSaved and paymentDoneByPayPal and deliveryScheduled ) or ( booksAvailableInStock and orderSaved and paymentDoneByCreditCard and deliveryScheduled ) Listing 2: Initial state and goal As an example, Listing 2 shows the initial state and the goal for the bookstore scenario.

two alternative goals are listed, the preferred one that describes the situation when payment has been done through PayPal, and the alternative to follow if paying through PayPal is impossible.


Tests conducted over six case studies proved that adaptive mapping does indeed improve the alignment process performance.

indigo was compared with three renowned matching systems in the domain and outperformed them.


The instructor also explained the experimentation to the participants.

the instructor explicitly reminded them that when deploying patterns to construct extensible software, one s objectives should not only ensure functional correctness and the use of design patterns in their programs, but also satisfy the theme of patterns.


In this paper we propose algorithms to determine the robustness of a given network.

two centralized algorithms are introduced.


Because the page is relatively young, it might not have been updated frequently.


SYMMETRIC FEATHERWEIGHT MULTI-JAVA We illustrate our ideas by extending Featherweight Java (FJ) [14] with symmetric encapsulated multi-methods, the result we call Symmetric Featherweight Multi-Java (SFMJ).

(i) we change the syntax for method de.nition and invocation to make all parameters explicit, (ii) we allow methods to be de.ned in the class of any of their parameters, and (iii) we introduce multiple dispatch.


There is just one claim in this example, which when re-written LORA notation is: .i ·.

(Bel i (Int agent1(Bel ia = 10))) some agent i eventually comes to believe that agent1 intends that i believes a has the value 10.


Any Java bytecode instruction that can throw an exception e.g., a .eld dereference, an array look-up, a cast, or a division must be treated as an implicit branch instruction.

changing the values .owing into such an instruction can change the control-.ow by causing or preventing an exception from being thrown.


The de.nitions of those class templates are required for type-checking such instantiations, but this introduces the potential for instantiation-time failures that break modular type checking.

it is possible that an instantiation of the algorithm will select a specialization of a class template that does not provide precisely the same members as the primary template.


The main reason for this is the ability of our approach to adapt to a given memory layout (though loop transformations).

suppose that an array is assigned a memory layout in multi-compilation based on Scenario VII.


is a placeholder and a special message block (but is not signed in a cryptographical sense as it will become clear later).

mi is treated as an ordered set Mi = {m1,...,me} or equivalently {(1,m1),..., (f,me)}; these representations will be used interchangeably as it will become clear from the context.


Second, the standard interface description mechanism of the SOAP architecture facilitates the composition of several distributed services to accomplish new tasks.

new functionality can be created by combining several web services.


To conclude, analysing the impact of obliviousness on the faultproneness of the evaluated systems provided us with evidences that support the H1 alternative hypothesis (H1-1).

obliviousness exerts impact on the fault-proneness of evolving AO programs .


List of 3D graphics APIs Name Top Platform OpenGL Khronos Group PCs, Workstations and Supercomputers Java3D Sun Microsystems PC DirectX Microsoft PC M3G (JSR 184) Sun Microsystems Mobile Devices OpenGL ES Khronos Group Embedded Systems Each of the APIs described in Table 1 were designed for the development of applications implementing 3D computer graphics 1 WEB 3D - http://www.web3d.org/ 2 WEB 3D - http://www.web3d.org/x3d-earth techniques widely used in industry.

the last two libraries mentioned were developed to aim of supporting development of 3D applications on mobile devices.


Other than these two changes we have tried to keep all the other features of Haskell not affected by these changes intact.


One of our rules for cast insertion is G f e e ' : T T = Object(X){ei:Ti}.i.

ei = x G f e.x cast(e ' , T , Object(X){x : Dyn}).x : Dyn when a program tries to read an object member that does not appear in the object s type, the object is cast to a type that contains that member at type Dyn.


We extend the SEJITS framework with a mechanism that enables the construction of meta-specializers that can implement   optimizations across existing specializers.

we use this mechanism to implement loop fusion[11] across specializers, inspired by the approach of Anderson et al[1].


We argue that it is quicker and easier to create usable documentation when thinking in terms of related artifacts rather than process.

it is more natural for a developer to point out the important artifacts in a system than to think about the steps required to modify it.


Our migration strategy makes no assumptions about compiler optimizations or number of code or data structures changed between versions.

the two processes are allowed to have arbitrarily different memory layouts.


3.3 Limitations A major drawback of static analysis and translation is that it is limited to decidable problems.

the compiler has to be able to infer the application s call graph, which implies three things.


Since the decisive di.erence to other forms of language composition is how we integrate languages, our terminology should re.ect that.

we aim to exclude systems where the extensibility is external to the host language.


each key-value update incurs 5.4 writes/entry.


Additionally, we have developed a domain-speci.c language for de.ning high-level resource management policies, and a facility for extending the kinds of resources that can be managed with our language extensions.

we introduce a new statement to C having the following syntax: require(r(a)) {...}.


For example, several of the policies investigated by Seligmann and Grarup [21] rely on the fact that trains are typically short.

they track a running estimate of the ratio of garbage encountered to aid in determining how aggressively to collect.


Rather than using an auxiliary unDecfunction, there is a more direct way to express the type of dataTypeOf s argument.

we can use lexically-scoped type variables, which is an independently useful Haskell extension.


Thus, the e.ectiveness of dynamic ABV depends on the quality of the stimuli that exert the ESW implementation.

the stimuli should try to stress the ESW functionalities to fully exercise the checkers and avoid vacuous passes of the corresponding assertions.


Similarly, the MultiJava type system can prevent a method M that is declared to be final from being overridden, in the sense that there can be no other method in the same generic function whose tuple of specializers is a pointwise subtype of M s. Restriction R3 allows this condition to be easily checked.

r3 ensures that the methods that a particular method M overrides are all available when M s compilation unit is typechecked.


An effective parallelization strategy should minimize the inter-processor data communication and synchronization (i.e., coherence activity should be minimized).

ideally, each processor should be able to execute independently without synchronization or communication.


.ow graph G * and the number of states (that is, it is of the same complexity as ModelCheck).

next, the cause of the error is computed as Causes = project(T) project(C).2 the cause lies along edges that belong to the error trace T but do not belong to any correct trace.


In particular, since we deal with radio link utilisation, the realism of the radio mediumwasexpectedtohaveavery signi.canteffect.Inthe small-scaleexperiment,1clientwas usedtoof.oad tasksto 5servers (2 of which were located within an area congested bya streaming entity generating traf.c).Weexamined three cases for each load sharing algorithm: (i) without contention, (ii) with contention (extra traf.c generated by the streaming node)but considering onlycomputational requirements, and (iii) with contention and using our approach which additionally considers bandwidth requirements.Fora more thorough evaluation of our algorithms, we also tested them on a largescale mote testbed.

we used the Heterogeneous Experimental Network(HEN) [1] deployed at the Departmentof Computer Scienceat UCL.We tested our algorithms using3clients,1streaming node and 21 servers.


As can be seen in the table, .ve of the six users achieved their best performance while using the Modi.ed LRU hoarding method, despite extensive experimentation with the clustering parameters in an attempt to .nd settings that would produce optimum performance.

the best hoarding method for most users involves applying several simple heuristic changes to standard LRU.


The logic can be used to reason about possible executions of multi-agent programs, and temporal patterns which can be enforced by agents and their groups.

it facilitates speci.cation and veri.cation of agents abilities wrt safety and/or liveness properties (with and without fairness assumptions).


There are more than 500 methods that contribute to exactly one use-case.

a third of all annotated methods implement speci.c use-case behavior.


Even in this case, BPActorsS is a subset of BPActors as some actors could be forced to manually execute their activities.

the business actors supported by the software system are identified through the intersection of the sets of actors included in the software system design, SSActors, and BPActors.


Furthermore, the cycle-accurate simulation only simulates 100M memory references while the cache only simulation above simulates a much longer 500M-memory reference.

mcf has no TLUS speedup but has about 0.8% overall speedup.


(a - x , ax) is referred to a layout such that the overall increased cache miss latency As a special case, when ay = a is less than the overall reduced row-bu.er miss latency, then the resulting memory access latency will be less than the original one.

we sacri.ce some cache performance in order to further improve row-bu.er performance.


that, since -.k uses abstract values of D , the transformation minimizes the worst error e which may occurs during an evaluation.

it minimizes the precision lost which may arise during an evaluation in the worst case, that is for the most pessimistic combination of data.


Total Qnty Cost S(e3) S(e2) Total S(u)  The relative references used in templates are very expressive: First, unlike absolute addresses, relative references are compositional.

they need not be adjusted when cells or blocks are composed with other blocks.


The purpose of unboxing optimization is to avoid redundant allocation of primitive CPython objects.

unboxing is used to assign a scalar value in the object to a stack-allocated variable so the corresponding object allocation can be eliminated.


Otherwise Web Services will become as monolithic as previous middleware technologies were.

features that Web Services are asked to provide will become strongly coupled with the application.


In this case we have three subactivities: one that monitors the pushing of the accelerator pedal, one that monitors vehicle conditions and one that takes the output of the other two activities and produces drive power and commands to the vehicle transmission.

the activity behavior is basically modeled as three concurrent subprocesses connected by data flow.


More precisely, given a (usual) mapping M from a schema S1 to a schema S2, de.ne thePC-mapping generated from M, denoted by PC(M), as: {(I1, I2) |I1, I2 are positive conditional instances of S1 and S2, respectively, and I2 is an Rpos-solution for I1 under M}.

pC(M) is obtained from M by including the pairs (I1, I2) of positive conditional instances such that I2 is a solution for I1 under M, according to the notion of solution for instances with incomplete information introduced in this paper.


The favorite ratio Fj of a task tj exe i,k i cuted on processor Mk is de.ned to be m max h=1 (Cj ) j i,h Fi,k = (9) Cj i,k jj j For any task t, a larger F value implies tis more suit i i,k i able to be executed on Mk.

ti j may have a shorter execution time if executed on Mk compared to other processors.


Note that, by virtue of out-of-place update, even at time t=12, the pages for reconstructing S8 are all still in Flash memory.

at time t=12, we can revert from S12 to S8, which is the basic idea of our proposed time-shift capability in Flash memory.


We believe that the usage of aspects to implement concurrency concern with JCSP introduces a new level of modularity.

our approach is not invasive (the Java source code is not tangled and scattered with the JCSP concurrency code).


In the current work, we call for cross product line analysis, namely conducting commonality and variability analysis of related SPLs for improving the management of current and future SPLs.

the input of the suggested method is a set of feature diagrams representing different SPLs.


Finally, note that the tables are not always symmetrical.

the f64column and row in Figure 4(b) are not the same.


Loop blocking has the second most impact on power consumption.

most of the spikes in the power consumption curve are results of experimenting with di.erent blocking factors.


d is the amount of unrolling that has been performed on the steady state.

one iteration of S corresponds to d iterations of the original loop B.


One interesting information DDT reported, the original linked list keeps a pointer to another heap allocated object as a data value.

the replaced data structure should be vector of pointers.


The product of service concretization on an enriched service model is a concrete service model.

service concretization is performed by selecting only one from the candidate services of particular nodes of the enriched service model according to functional and context-of-use requirements.


The design of the .ash translation layer has a strong impact on the read and write performance with consideration of the size of available memory.

the management of mapping information usually trade-offs between access performance and memory consumption.


To this end, the SoSAA adapter provides meta-level perceptors and meta-level actuators modules, which collectively define the interface between the two layers in SoSAA.

the SoSAA adapter sets the range of the possible interventions and monitoring capabilities of the intentional layer by distinguishing between the capabilities of the infrastructure and those of the application.


5.5 Effects of different HPC approaches A central question of importance to HPC research is, what are the strengths and weaknesses of the given HPC approaches?

if an HPC solution is going to be applied, what are the tradeoffs between cost and benefits for different problem types?


Second, the need for address translation is greatly reduced.

if node *head is never updated during execution, then we will not make a copy of this node.


With Proposition 2.1, the theorem follows from structural induction on the typing derivation of 0/;0/ f e : t. Combining Theorem 2.5 and Theorem 2.6, we clearly have that the evaluation of a well-typed closed expression e in .code either reaches a value or continues forever.

this indicates that the problem of free variable evaluation can never occur in .code.


Again, such checking is already a part of Java s modular typechecks.

java signals a static error if a class contains two methods of the same name, number of arguments, and static argument types.


writes to) and use mloc(t) to denote the global memory location that the transition accesses.

if the transition does not read or write a global location, then mloc(t) returns .. only in the case where a transition t accesses a global memory location does mloc(t) return a non-.


Each VM hosts one PC, which controls all the VPs on that VM.

all messages sent by a VP to the synchronizer pass through the PC.


Further, since type names are used as they are defined in foreign schemas, there is no need to redefine them again in the host language.

we use the existing names of foreign types; we do not create corresponding types in the host language!


Figure 7(e) shows that, DAC performed very differently with these three parameter-value sets.

under the PC workload DAC performed poorly with the best setting of the RND workload.


To facilitate the acceptance of MPM we decided to maintain a strict compatibility with existing tools.

mPM has been developed to be used as a drop-in replacement for apt-get / aptitude and to provide an easy-to-use alternative to solve complicated problems for which the apt solvers are unable to .nd a solution.


In order to present the user with code snippets, we keep a mapping from speci.cations back to the snippets from which they were created.

each edge in a (consolidated) speci.cation is mapped to a set of relevant snippets.


In the above formulation, we have reformulated the objective to maximize the auxiliary decision variable ...0,1. representing the overall satisfaction with the three normalized objectives ...,..., and ....

the auxiliary objective is to find a configuration that maximizes ., which is constrained by the three normalized objectives, resulting first in their optimization.


While this strategy provides isolation, it can also be quite expensive if implemented naively.

a new VM can incur signi.cant overhead initializing, booting an operating system, and loading application software.


In the grey area on the left is a collection of actors that collectively implement the state function g. We assume these actors are black boxes that conform with the actor abstract semantics.

they could be internally implemented as composite actors with SR or DE directors, for example, or as modal models [21].


In this paper, we propose special purpose programming constructs to improve the practical application of BDI-based agentoriented programming languages that have formal semantics.

we suggest to extend such BDI-based agent programming languages with explicit programming constructs for declarative goals, their dynamics and di.erent types of goal test actions, events that notify agents about external environmental changes, exception handling mechanisms that notify the execution failure of plans, a recovery mechanism to repair failed plans, di.erent execution modes for plans, and dedicated programming mechanisms for procedure calls and recursion.


This subtle addition signi.cantly increases the power of type-variable constraints.

f-bounded polymorphism addresses the issue of binary methods, the pattern that operations such as comparison and addition need both arguments to have the same type.


The measurements are the time spent, the number of failed functional test cases, and the time spent regarding only those submitted programs with no failed functional test cases found.

in the direct approach, the time spent is the time taken by the subjects to revise the original version of JHotDraw.


Observe that, for large values of q and/or r (> 0.5), the sample mean of m (mean(m)) for Method A is smaller than that for Method B as the simulations have higher chance to reach the state serr (Fig.2) and satisfy(tt U error).

for models where the probability p for satisfying a desired property decreases dramatically with the transition probability variations, MethodA may su.erfrom the higher mean and variability of computation cost.


Because the latter does not exist in general!

the union of two valid Rs is not always a valid R. For instance, consider the union of R3 and its inverse R-1 = {(V ',V,t) | (V,V ',t) .R3}.


The purpose of this split is to create a setup whereby three system components can cooperate to blindly perform duplicate detection.

none of the three system components can de-anonymize or link client data.


PROOF OF CONCEPT This section presents an proof of concept implementation on the TinyOS operating system diagnosing on a typical sensor network application: Data collection from a set of distributed sensors, e.g., as used for environmental monitoring.

we use the MultihopOscilloscope applicationbasedontheCollectionTree Protocol(CTP).We performed experiments withdi.erentdiagnoses formulated inMoMi(a) inthe TinyOS simulator TOSSIM,and(b) on a 24-node testbed of TNOdes [5].


While the same or different errors can be made again and again with the text editor approach, an update program satisfying certain safety criteria will preserve the correctness of all object programs to which it applies.

the correctness of an update is established once and for all.


This paper shows how such interactions are crucial to realize ef.cient HWDSs.

we investigate HWDSs from a holistic view that incorporates processor architecture, OS, and applications.


2.1 Client Reasoning Because the mandatory calls of a HOM typically have weak speci.cations, the HOM s speci.cation will typically not be suf.cient for client-side reasoning.

if a client wants to know that a call to a HOM accomplishes some speci.c state transformation, then the HOM s weak speci.cation will generally not be enough to prove what the client wants.


Building Special-Purpose Allocators In this section, we investigate the performance implications of build- ing custom allocators using heap layers.

we evaluate the performance of two applications (197. parser and 176. gec from the SPEC2000 benchmark suite) that make extensive use of custom allocators.


Note that any reference occurs during a hibernating period is not sampled and will not be used as the starting point of a distance measurement.

a reuse distance measurement always counts the number of distinct data accessed between the current access and some reference appeared in a sampling period.


Active mediation exploits the notion of mobile code [12] to provide for unforeseen remote information processing.

matching, reformatting, rearranging, and mapping of data being sent or received among services can be embodied in mobile code, and shipped by the composed application to the remote service as needed.


Thus, one needs to modify the chase procedure to take into consideration the element-conditions in positive conditional instances.

one has to consider that some relationships between null values can .re the application of a dependency, and one has to make explicit these relationships in the generated tuples by using new elementconditions.


We also assume that the variance propagation function is linear with coef.cients a1,...,am.

if fu has an arity of m, and each input xi is approximated by some input x i such that E[|xi - x i|2] = vi, then the .nal variance: E |fu(x1,...,xm)-fu,i( x1,..., x m)|2 = aj vj +2Vu,i .


Reuse distance is simply the same as LRU stack distance or stack distance using LRU replacement policy.

bunt has produced a host of publications studying both kinds of locality ranging from his seminal papers [11, 24, 23] to various investigations of metrics and measurement techniques.


We .nd our convention more intuitive for the intended use of the tool.

the inputs causing the error may never occur during normal application execution due to conditions established by the rest of the code and not re.ected in the method s preconditions.


We show that this pattern enables compositional synthesis of feature arrangements.

the pattern allows us to add or remove features from an existing system without having to recon.gure the system from scratch.


Note that ratherthan designingarefactoringthatappliesonlytothe attribute for alternate text concept, the programmer has designed a parameterized interface so that it can be applied to any attribute of any class.

the AttributeConcept from Figure5takes three parameters: targetType is the class for which the attribute is de.ned, attrType is the type of the attribute, and attrName is its name.


The solution selected in OBAN is based on a Kerberos ticket generated within the OBAN architecture.

a user terminal gets the ticket after correct authentication with the AAA server belonging to the party offering OBAN connectivity.


Since the adverse effects of code growth quickly become prohibitive, many limitations are placed on the inlining routine.

inlining is usually limited to very frequently executed call sites with very small callees.


However, for these cases other assumptions instead of maximum progress may be needed.

for learning triggers a maximal laziness assumption would be needed to highlight scenarios in which if the system is not forced (triggered) to perform an action, then an undesirable situation, such as a goal violation, will occur.


to L, and thereby limit the number of such .elds.

it is not necessary to map h2 to L, which causes .eld f to be tracked.


GPU memory architectures are significantly different from CPU memory architectures [21].

gPUs consist of high-bandwidth, high-latency video memory and the GPU cache sizes are significantly smaller than the CPUs therefore, the performance characteristics of scatter and gather operations on GPUs may involve different optimizations than corresponding CPU-based algorithms.


The simplest is to use DMTCP s publish-subscribe feature to generate globally unique virtual rkeys, and update a global table of virtual-to-real rkeys.

one could use the existing implementation before the .rst checkpoint, and then switch to a publish-subscribe implementation after restart.


I explained that, as this was an exercise in modeling, the most important factor was the consistency of the modeler s view of the world and the model.

as we read through the submissions, we expected to see a description of the domain followed by a model and the rationale for the model given the domain.


For example, when building the instantiation D, we compute the type handles for Set<str~ng [] > and Lis't.

these type handles are stored in the vtable that acts as the unique mntime type for D. for each open type expression, a slot is reserved in a type handle dictionary stored in the vtable associated with a particular instantiation.


First, the length of the paths (de.ned as the number of arcs in the path) traversed by ants in the construction phase is limited.

when the path of an ant reaches a given maximum length .ant the ant is stopped.


Finally, we evaluate our operational prototype on several applications, and show that statistical techniques offer an effective strategy for assessing application scalability.

we find that non-parametric correlation of the number of tasks to the ratio of the time for communication operations to overall communication time provides a reliable measure for identifying communication operations that scale poorly.


Because of this, evolution did not follow the same path taken after the last chzckpoint.

the genetic algorithm was controlled by different random numbers and therefore searched a different part of the search space.


Introduction Keeping functionally different parts of an application separate is an important step to take in order to avoid excessive complexity while retaining .exibility.

in the domain of graphical user interfaces, the separation between the user input on one hand, and the construction and validation of result values on the other hand, has been a closely studied area in recent years.


This would allow us to refactor all programs that originate from a physically separated program, but unfortunately (or fortunately, depending on the point of view) virtual separation is more .exible and expressive because there is no feature order and because, like in Figure 3, statements in the middle of a method can be annotated [26, 24].

in  class Foo { class Pxy { C x; C y; } C m(...) { class Foo { ... C m(...) { ... #ifdef A p=h(p, x, y, z); y=z; x=p.x; y=p.y; x=z; ... return x; #endif } ... Pxy h(Pxy p, C x, C y, C z) { return x; #ifdef A y=z; x=z; #endif } p=new Pxy(); p.x=x; p.y=y; } return p; } } Figure 6.


In this case, upon packing the checkpoint operation within a given entry of checkpoint slots[], the LANai control program adequately sets the next .eld of the X-th DMA control block in that entry in order to make it point to the .rst control block of the successive entry of the vector.

the last (MAXBURSTS.X)DMA control blocks within that entry of checkpoint slots[] are unlinked from the chain of control blocks.


Thus, at the end of the algorithm, .post is the conjunction of all equality predicates that hold for pairs of post-states resulting from pre-states matching .pre.

.post is the strongest liberal postcondition of .pre for the observed executions R. Checking the condition at line 3 and computing the set and the intersection in line 4 can all be done in O(|M||EQ|) time.


The choice of the option is arbitrary and many other types could be used.

it is possible to generalize the return type of a pattern matching function to anything that implements Haskell s MonadPlus type class (Tullsen 2000).


The main reason for this is that, as explained earlier, the applications in our experimental suite are optimized through several source-level communication optimizations that minimize inter-processor data communication.

the compiler is very successful in reducing the amount of inter-processor communication.


a) NotProd :: Ty t t The .rst argument to Ty is the type we want to pattern match on and the second argument is the result of applying Prod to that type.

the inhabitants of type Ty t t ' are evidence that Prod t = t ' .


We then apply logic programming tools to animate, compile and model check OPNs.

we use the partial evaluation system logen to produce an OPN compiler, and we use the model checker xtl to verify CTL formulae.


We observe that the energies of any two successive energy-time labels di.er by a factor of more than (1 + 8) (otherwise, we have already eliminated it).


Restrictions include removing BBIEs, ABIEs, and ASBIEs.

these artifacts are omitted in the derived context speci.c business document model.


Np do 7: send(msg,n) 8: end for 9: end if ity of reception of messages.

it is importanttounderstand whetheralowgame eventreceptionrate is due to a poor dissemination caused by the gossip algorithm,rather thana lowgenerationrateby agivennode.


F. For ease of notation, for the rest of the introduction we .x a positive integer d which will be implicit in some de.nitions.

we denote by Cd the the set of functions of degree at most d.Cd = {f : D .


4.2 Design of New Disk Schedulers In this section, we describe new I/O schedulers for SSDs.

the new schedulers utilize the order freedom of read requests and LBA-bundle writes to implement specific policies such as maximizing fairness or minimizing response time.


We give examples from the literature, and report on experiences we have had with evolving systems to corroborate the idea that the explicit modeling of assumptions is worthwhile.

we explicitly model assumptions in the architectural views of an existing product family, namely the product feature models and product component models.


n simply by .nding a context C where we can unfold M to .C[M ] and fold .C[N ] to N. the following proof is valid: r .


In the following, we demonstrate utilizing the evolution patterns as reference models for evaluating the work presented in [10].

the authors provide an approach for migrating model instances based on changes applied to the metamodel that the model instances conform to.


a capability, since it serves as a bound on what types may be used concretely in the continuation of an update.

any code following an update must type check using G restricted to those types listed in the capability.


In X10, this is achieved through the annotation mechanism.

the Inline and NoInline method annotations can be used to force the inlining of hot paths and maintain the outlining of cold paths.


Given a cell in the dual space that contains the edge of the shadow, and assuming that the motion of the shadow is relatively slow, one of the sensor nodes corresponding to one line segment that forms the cell can move, so that the size of the cell shrinks.

we can optimally choose the sensor node and its motion, so that the size of the cell is shrunk the fastest.


5.1 Concurrent region instrumentation The JIT compiler instruments concurrent regions as illus trated in Figure 12.

the JIT compiler uses the rdtsc instruction to measure the execution time.


These threats could be reduced by further experimentation on a wider type and larger number of policies and a larger number of mutation operators.

lower-level mutation operators are needed to operate on the subject, resource, and action attributes found in various policy elements.


In contrast, we leverage the Uni.ed Modeling Language (UML) to present information about each design pattern.

we present structural diagrams through UML class and component diagrams.


Despite these advances, though, the specialist middleware approach has a number of very significant limitations.

these solutions remain narrow in scope and do not help with problems such as interoperability with other domains.


In our approach, the interaction based service notion emerges as a cross-cutting modeling element regarding both system structure and behavior.

we have established a decoupling between services (functions) as modeling elements and implementation infrastructures on top of which services can be implemented.


However, this alone is not a strong enough invariant to guarantee the indistinguishability of whole traces.

if the two machines perform a Return from a high state to a low state, we would need to conclude that the two low states are equivalent without knowing anything about the original high states.


This has enabled us to complete veri.cation runs that sequential analyses have been unable to analyze previously.

we have been able to complete every driver-property benchmark we have with BOLT, several of which we have previously found impossible to complete.


In 1), the context elements that a.ect the behavior of a targeted system are extracted.

the boundary of contexts that should be taken into account is explored by using CAMEmb.


So we then check whether the non-space character appearing nearest before input isa < .


Second, we hypothesize that a unified model can further improve our ability to modularize systems, with benefits in evolvability, understandability, communication overheads in development, and parallel development.

abstracting from the example of the last section, we see that the unified design supports, as a practical possibility, what we might call modularization of higherorder crosscutting concerns.


Our approach generates new code, and does not require a corpus of existing code to mine for snippets.

users could bene.t from our system in very small projects that they are just starting.


Moreover, it contributes the technical realization of the translation process, making the j language family executable on top of this delegationbased VM prototype.

the presented language implementations are j, cj and iaj, the latter containing the features of both ij and aj.


Note that the second result holds for arbitrary size domains (even exponential) and a more limited class of f, while the .rst result has more general f, but holds only as long as the domain is not too large and the perturbation is not too small.1 We can use the .rst result to obtain separate generalizations of the DN attack to a larger domain or a smaller pertur(we mention several generalizations later in the paper).

we will focus on databases representing graphs, and consider summation queries, where the entries included in the sum depend on the global structure of the graph.


In addition to the time dilation support mentioned above, we have also added the ability to pause, unpause, and sychronize guest time to a provided reference time source to Palacios.

palacios now keeps track of how often timer events are read or injected into the guest, and uses this information to bound how quickly it o.sets guest time towards the desired target time rate.


It is also highly desirable to provide this extensibility in an vendor-independent way.

an extension module should be portable across different middleware implementations.


(Post a sin sout cout res) This predicate represents the notion that the instruction i is correct with respect to the speci.cation given by the precondition P re and the postcondition P ost.

the predicate is true if the execution of i on a state verifying P re results in a state verifying P ost, assuming that no fatal error has occurred.


Additional factors considered include nested regions, the distribution of regions with the same variables or expressions among different files, distribution of similar code between different regions, and others.

our focus on conditional regions as defined by the preprocessor directives is driven by the fact that code found in regions associated with the same conditional expression essentially could correspond to an aspectoriented concern.


One of the bene.ts is that a formal semantics allows us to prove the correctness of optimisations for CellML, and this is described in more detail in Section 3.

implementing partial evaluation also within Haskell makes the proof of this technique relatively straightforward.


The main objective of having an incremental approach is to give the students a practical experience of managing integrated and tested releases of system that is more aligned with the requirements.

the advisors (i.e., tutors and/or the lecturer) can offer timely feedbacks only if students are able to showcase the system regularly with incremental delivery of functions.


Though we propose two speci.c protocols for the node capture detection, the main focus of this work is to investigate a new approach for detecting such attacks.

we exploit emergent properties of mobile sensor networks, and our solutions are based on the simple observation that if node a will not re-meet node b within aperiod ., thanitis possible that node b has been captured.


T )£e which are present in [20, p.2] and in [22, Fig.1].

the interpreters in [20] work with them.


Of course, there is a cost to developing a software factory in order to realize these benefits.

software factories exhibit the classical cost-benefit trade-off seen in product lines [28].


The need for a practical tool is becoming even more urgent with the widespread adoption of agile development, which heavily relies on (regression) testing [26,35].

although we did not account for Test Driven Development (TDD) in our study, the practical impact of such testing-oriented software development methodologies on RTS is still largely unknown.


we will try to answer the question: Is the length of an information flow indicative of its strength?


Moreover, while convergence is deterministic, the ex- ceptional convergence is not.

a term may raise many different exceptions; which it does raise when evaluated is decided upon at run-time.


Besides showing how to compute this information we explain how it enables further user interface functionality to be encoded as reusable algorithms.

we show how this information gives the means for algorithms for the enablement and disablement of widgets when they are not relevant to the result of a user interface, and activation and de-activation of command widgets when the current result of a user interface does not satisfy stated conditions.


Events registered in functions called from the interpreter function were not taken into account.

in the current section unless otherwise speci.ed total time values are only measured for the time spent in the interpreter loop, be it of a direct-threaded interpreter or code-copying one.


The quality strategies conform to the architectural meta-model of styles.

the strategies comprise structural and interaction information about components involved in the achievement of the quality.


The votefor eachcandidateeventis also weightedaccording to its elimination ef.ciency for a location area, which isde.nedashow equallyin size(orindiameter) an event can cut an area.

an optimal scan event cuts an area in the middle, since this cut shrinks the area quicklyand thus reduceslocalization uncertaintyquickly.


1 Introduction User-declared datatypes and pattern-matching in functional programming languages like ML and Haskell simplify one of the main tasks for which these languages were intended, namely metaprogramming the construction and manipulation of syntactical structures.

the declaration of recursive functions for manipulating the parse trees of object-level languages is made much simpler (and hence less error prone) through the use of patterns to match against parts of trees.


For example, when storing two 32-bit integers constants into adjoining locations in a structure, the optimizer may generate a single 64-bit store of an appropriate constant.

optimization can generate nonportable code, which runs faster on the current CPU, but nowhere else.


Secondly, we would like to undertake more work on the implementation.

we would like to use real mobile devices, and we would like to do this in a way that requires the least amount of changes to their existing software.


3.4 Hierarchy-Aware Energy Management A common point between the default strategy and the leakageaware strategy described above is that they both operate with the same data access and transfer pattern.

the data transfers in both the schemes occur in exactly the same manner.


3.2 The XCAP Program Logic Bedrock s veri.cation support is inspired by XCAP [22], a program logic for assembly programs that manipulate .rstclass code pointers.

bedrock directly adopts XCAP s assertion logic (in which code speci.cations are written) and uses a proof approach inspired by XCAP s program logic (in which programs are proved to satisfy their speci.cations).


To counter these problems, our goal is to extend Matlab/Simulink with an explicit .rst-class variability modeling concept that support modular and hierarchical variability modeling for dealing with large and complex variantrich systems.

we aim at an integration of this approach into the existing development processes and tool infrastructure within Matlab/Simulink.


// First create a RandomAccessFile object, then /I calculate offset in file RandomAccessFile raf = new RandomAccessFile (filename,access); raf.seek(position); // calculate offset within byte array and number  // of bytes to write, then perform write raf.write(buf,my_start_buf,num_bytes); It is important to note that this approach works correctly both when existing file is overwritten and when a new file is created, because of the semantics of the seek method.

a seek to a location past the end of the file, followed by a write, extends the length of the file [18].


In other words, we wanted to determine which tests caused the output of the mutant Pm to be most different from the output of P0, and hence most visible.

we are interested in tests with maximum S for each mutant Pm.


Based on this survey result, we posed the following hypothesis: H5 The cost per line of code for parallel code (MPI or OpenMP) will be greater than the cost per line of code for serial code We use the effort data from C3A3, described in Section 4.3, to investigate the cost of HPC code in terms of the amount of effort required per line of code.

we compared the cost to develop a serial version from scratch to the cost to develop an HPC version starting from an existing serial implementation.


In their proposed design, the SSD informs the host where it stored a particular block; the host is responsible for keeping appropriate mapping information.

the host and the SSD communicate using physical .ash addresses rather than LBAs.


Earlier work has also demonstrated that there is no direct relationship between these two refactorings [3].

they are independent, and neither uses the other.


Under AIMD, each application adjusts its demand based on the congestion signal c(t) accordingtothe equation: nv(t) n.v(t)= (1 - c(t)) - c(t) v =1, 2, .., V (7) 2 where the .rst term represents the additive increase of one unit of demand and the second term, represents the multiplicative decrease by halving the demand.Figure 2 depicts the general control block diagram for the model presented above.12 11In general, we denote that change in a variable x(t)by .x(t) 12Since VMs are running on the same physical machine, the e.ect of feedback delay should be negligible, and hence is not accounted for in our model.

p(t), the appropriate congestion signal, c(t) will ensure a fair convergence across the VMs.Clearly, the convergence time depends on our choice of parameters.a small value of .


However, in a sense, we follow the Cray ISAs more closely than the microprocessor-based RISCs.

we use hierarchical register files with a very small file at the top of the hierarchy, variable length in- structions, and in-order instruction issue (albeit within individual processing elements).


This situation is more complex as software can be developed by multiple organizations and this happens to some extent without explicit synchronization.

a customizable software platform may be built by one organization, while another organization builds software on top of this [5].


3.3 Data Recovery on Errors The proposed two-version-based strategy could roll back a .le to its latest valid snapshot when the current version of any chunk of the .le is corrupted.

when the current version ck,2 of a .le chunk ck at time ti is corrupted, its .le can be rolled back to the latest valid snapshot Sr that includes ck,1.To reconstruct Sr of the .le, chunk IDs in the candidate queue are popped out to check up their relative position so as to e.ciently determine the chunks that need to be rolled back.


The literature suggests that Reflexion Modeling is effective in identifying inconsistencies between the as-implemented and asdesigned architecture of existing systems [8] in hindsight.

it has been successfully trialled in situations where architectural inconsistencies have become entrenched in a deployed, evolving system over a long period of time and the organization has retrospectively decided to identify these inconsistencies.


Using this information and the dataflow relationships, the Test-Count Technique has assigned an estimated fault likelihood, visually represented by varying shades of red (gray in this figure), to each non-input cell in the spreadsheet.

the visualization shows the fault likelihood of Regular_Pay, Overtime_Pay, and Gross_Amount to be estimated at Medium while Withholdings and Net_Amount have been estimated at Low.


From the premise we know that Gfirst(pa) = Gfirst(pb) and hence Gfirst(pb) = Glast(pf ).As pw is a maximal atomic cover, we know that inatomiclast(pf ) = .. From the fact that client transitions cannot synchronize (they cannot execute atomic statements or access global memory), and that a process cannot access the local variables of another process, it follows that process q can execute m2 concurrently with m1 from state last(pf ).

there exists an execution pbase1 · pf · pbD.


Secondly, the use of such a high-level intermediate form also allows us to perform sophisticated optimization.

we are interested in targeting automata (eventually in the form of an imperative program) as our .nal code.


Consequently, both these techniques should be applied with care.

we need to minimize the number of merge and split operations in converting a cyclic graph to a non-cyclic one.


Given any such order, we rank the children of each node accordingly, as follows: if v is the ith child called by x, then the rank of v is set to ¢(v) = d(x) -i.

the child ranked 0 is called at the latest possible time.


A recent tool GKLEEp [18] provides more scalability by exploiting thread symmetry, but still requires users to pick the symbolic inputs.

this tool partitions the space of executions of a GPU program into parametrically equivalent .ows, and models the race analysis problem over two parametric threads in each equivalence class.


But this code can be thought of as atomic if the programmer cares only about the multiset of elements in the .nal list.

the example program in Figure 6 is semantically atomic with respect to some bridge predicate like equalMultisets(list,list ), where equalMultisets is a function that compares two collections to see if they have equal multisets of elements.


In this research study, we evaluated the potential of home robots to serve as a compensatory technology for older adults.


It is organized in two blocks (see Figure 4): (Block A) display contextual information, and (B block) proactive alerts.

the provision of proactive alerts on a hardware platform that can follow the user, while he/she performs its activities in di.erent places, maximizes the ubiquity of the proposed context awareness service.


Note that when OpenSSH and Pure-FTPd authenticate through PAM, we identi.ed the same authentication point.

the FTA initially detected two functions that both matched Rule 1 and 2, namely verify_pwd_hash and _unix_verify_pwd.


A component is notified about thematic information if the intersection among publication and interest contexts is not empty, by considering also the indirect matches obtained by applying the transitive property to direct mappings.

a publication context PC matches an interest context IC if .


4.4.2 Concurrent Workloads We next investigate how AutoDVS performs when multiple applications are running concurrently on an iPAQ.

we replay the event trace while running the Madplay MP3 decoder (music player) in the background.


The worst-case bound holds even though A and B can di.er drastically.

there can be inputs for which policy A will incur many times (up to the memory size M, which can be from many tens of thousands to a million for real systems) as many faults as B and vice versa.


The distances between points in the figure reflect the n-dimensional distance between the corresponding profiles.

if two points are far apart in the display, then the corresponding executions have very different profiles.


For a parallel garbage collector, this means that a bound on the worst-case performance has to be found.

a limit has to be given on the time lost due to processors that are idle since the garbage collection work cannot be parallelised fully.


If there are more requests in the queue when dispatching stops, then the cumulative disk time allocated to qi could be more than the assigned quantum, i.e., Ti k >Qi.

the last request was dispatched when Ti k <Qi, but the time to service the request was larger than the remaining time in the quantum.


for arbitrary hierarchies the performance of binary matrix is asymptotically optimal.


Various solutions have been proposed for this problem, typically based on explicit support for timing functions.

very good results are obtained by using soft timers or one-shot timers.


Core HE R M E S Algorithm ( X for Workpath Sensitivity and X for Workload Sensitivity) 3.3 Uni.ed Algorithm Speci.cation worker may be left with a large number of work items when it becomes immediate.

a slower tempo in- The two tempo control strategies are designed to complecreases the workpath length.


We do it in the next section, but before we want to address the possible doubts of a reader about what the denotation of a .nite type like Bool is in such models.

since this denotation contains not only (the denotations of) true and false but in.nitely many other elements, then the reader can rightly wonder what these other elements are and whether they carry any intuitive meaning.


The .rst problem, which we call allocation, determines the processor core to execute a given loop iteration.

it distributes the loop iterations across available cores.


Such an event must synchronize with receive c.  Perhaps the most powerful of CML s concurrency primitives is the combinator choose; it can nondeterministically select an event from a list of events, so that the selected event can be synchronized.

choose can express selective communication.


Look-up rence of a self variable in a program P is implicitly annotated with an identity substitution id.

we regard Z as an abbreviation for Zid .We use .


Effectiveness of Cross-Platform Optimizationsfor a Java Just-In-Time Compiler Kazuaki Ishizaki, Mikio Takeuchi, Kiyokuni Kawachiya, Toshio Suganuma, Osamu Gohda, Tatsushi Inagaki, Akira Koseki, Kazunori Ogata, Motohiro Kawahito, Toshiaki Yasue, Takeshi Ogasawara, Tamiya Onodera, Hideaki Komatsu, and Toshio Nakatani IBM Research, Tokyo Research Laboratory 1623-14 Shimotsuruma, Yamato, Kanagawa, 242-8502, Japan ishizaki@trl.ibm.com ABSTRACT This paper describes the system overview of our Java Just-In-Time (JIT) compiler, which is the basis for the latest production version of IBM Java JIT compiler that supports a diversity of processor architectures including both 32-bit and 64-bit modes, CISC, RISC, and VLIW architectures.

we focus on the design and evaluation of the cross-platform optimizations that are common across different architectures.


The intent of the experiments was to explore whether taking bandwidth utilisation into account would indeed lead to substantial decreases in the latency of a real WSN.

since we deal with radio link utilisation, the realism of the radio mediumwasexpectedtohaveavery signi.canteffect.Inthe small-scaleexperiment,1clientwas usedtoof.oad tasksto 5servers (2 of which were located within an area congested bya streaming entity generating traf.c).Weexamined three cases for each load sharing algorithm: (i) without contention, (ii) with contention (extra traf.c generated by the streaming node)but considering onlycomputational requirements, and (iii) with contention and using our approach which additionally considers bandwidth requirements.Fora more thorough evaluation of our algorithms, we also tested them on a largescale mote testbed.


It uses many visual cues to represent the blog content and social interaction history with the blog entry which help to navigate the blog archive quickly and easily.

visual cues about the social response (comments) to the news can be used to help users navigate stream data quickly to find interesting news.


Initializing a ReadStream requires two-phase initialization like for ResultSet.

the code to create a ReadStream x that is not at the end is val x = new ReadStream; x<-this.notEndState;.


Carol could represent a precious resource, and for that reason Alice may want to limit the lifetime of the reference it hands out to Bob.

alice wants to have the ability to revoke Bob s access to Carol.


The analytical research paradigm is not suf.cient for investigating complex real life issues, involving humans and their interactions with technology.

empirical research needs to complement theoretical studies in order to advance understanding with respect to the use of technologies.


Experimental results performed on a wide range of situations, together with comparative evaluations against two variants of the epoch-based technique, show that the evaporative approach is able to handle the dynamism of the values measured over the network in an e.ective way, and in the most of the cases is more accurate than epoch-based techniques.

the evaporative solution is to be preferred either in very-large networks or whenever periodic restarts are to be avoided.


non-interference A metaproperty behavior should not modify or interfere with the host program except through a well-de.ned interface.

a host program should be able to control whether or not it is a.ected by a metaproperty behavior.


For convenience, we restate Theorem 5 in terms of relative capacity.

the relative additional server capacity is strictly less than W1u1 - (1 + e)W1,where u1 is the ratio of U1 to the streaming rate R. Simulation results are shown in Table 3.


46022, Valencia, Spain {sabrahao, einsfran, pcarsi}@dsic.upv.es In this paper, we present a controlled experiment to assess whether the use of stereotypes improves the comprehension of UML sequence diagrams.

we consider a set of stereotypes that have been proposed to enrich the semantics of interaction messages in UML sequence diagrams in the context of a Requirements Engineering approach for model-driven software development [3].


APPROACH Our approach for translating a Java program Pinto a RTSJcompliant, scoped memory-aware program P0, is based on two kinds of analysis.

for a given object instance x,we seek to answer these two questions, analogous to the two criteria introduced in Section 2: 1.


The application of SAT solvers for creating con.gurations of and verifying feature models is not new.

the formalization of feature models based on predicate logic presented in Section 2 was inspired by Batory s work [2], which also recommends the use of SAT solvers.


Second, it uses an interval caching technique to cut down the memory space required to describe the mapping for a LPA range whose corresponding PPAs are also contiguous.

rather than using X PMT entries to describe a contiguously mapped LPA region with X pages, SOFA uses three numbers to describe such a LPA region: the starting LPA, the starting PPA, and the region s size.


Compared to previous approaches to dynamic slicing, this gives us more control when choosing which statements to include in a slice.

based on the user s needs, our approach can generate different slices for the same criterion and input.


This process reduces the number of periodic d-dimensional disk allocations from 2 Nto 2.

every periodic disk allocation is equivalent to a periodic disk allocation in which the .rst term is .


4 Case Studies To illustrate the applicability of the framework and augmented sequential programming model, this section describes the manual application of the techniques from Section2totheCapplicationsintheSPEC CINT2000 benchmark suite.

for each benchmark, the loop and its parallelization are described.


Just as the HTML combinators, most domain-speci.c languages are implemented via shallow embedding [110].

we de.ne a set of base combinators that embody the semantic algebra of the embedded language, and glue the primitive operations together into bigger denotations using the host language s abstraction mechanism.


Frame LanguageTranslation (Excerpts) .I provides access to the underlying frame with,frameof, and valueof commands in .F , allowing code to access and manipulate the information-.ow metadata.

this allows code to endorse and declassify data in integrity and con.dentiality environments, respectively.


All the Java analyses mentioned above are whole program analyses.

the analysis relies for correctness on knowledge of the whole program rather than working on individual classes or methods.


In the reminder of the paper, ASM rules are given in the XASM [3] dialect compiler.

the ASM based transformations start from an algebra encoding the source model and return an algebra encoding the target model.


Hence, the meta-program reduces to C = { /*as before*/ } D = { i n t h(){ r e t u r n new o u t e r .D().k();} i n t k(){ r e t u r n 1;} } which is a well-typed program.

now the expression new outer.D().k() can be successfully typechecked.


Consider now the priorities associated with each object in the application: DATA PROVIDER PRI for both data providers, COLLECTOR PRI for the collector, STORAGE DE-VICE PRI for the storage device and VIS DEV PRI for the visualization device.The priorities have the following relationships: Relationships_among_priorities: DATA_PROVIDER_PRI > STORAGE_DEVICE_PRI & STORAGE_DEVICE_PRI > COLLECTOR_PRI & COLLECTOR_PRI > VIS_DEV_PRI.

vIS DEV PRI is the lowest priority.Considering that the priority propagation model associated with both the Collector and the StorageDevice is CLIENT PROPAGA-TED (see Figure 4), the two following lemmas can be demonstrated.


Think of it as deploying a (component-based) web-application: it determines the way the different components are wired, but it does not contain any application logic.

it maps the abstract types to a concrete composition of implementations, thus resolving the components requirements.


Such services might originate from different sources.

it is likely that a typical user task will be composed of several mobile services with the possibility that each service is provided by a different vendor.


Thus, we attempt to adopt current register allocation algorithms to perform CCSM allocation.

we choose to modify the register allocation algorithm proposed in [8] since it achieves optimal spilling.


indent is freely available and ported to many platforms and operating systems.


Aiming to calculate the life time of each node in member table and deal with the synchronization issue among nodes more lightly, the local clock of the newly joined node should be synchronized with RP in login process.

the participating node sends a UDP packet containing its local time.


In developing the client side, efforts were also made to relax certain other limitations imposed by the Java security sandbox on some needed operations.

we refer here to the snooping activity of a JavaScript in the top frame.


Then, physically serializable executions of these transactions must result in either the order (x,y,z) or the order (z,x,y).

(x,z,y) is not a valid result as it would violate the atomicity of Transaction 1.


CRESCENT is designed as a low-cost testbed that can be deployed on commodity computers with typical RF interfaces, without the need for attaching any other special hardware.

cRESCENT makes use of the MAC and PHY protocols of conventional 802.11 cards, allowing the user to focus only on the implementation of the routing protocols, with integration with USRP and WARP boards if needed.


This paper presents an integration of a series of techniques into a tool-suite to help developers the tackle aforementioned problems.

the paper explains how a chain of techniques helps programmers to produce sound and predictable scope-memory managed code from conventional Java code.


Given the median precision of 0.84 achieved by one of our method-level based prediction models (see Table 4), a developer has roughly the same chance of picking a bug-prone method by randomly guessing after eliminating 6 out of those 11 methods (4/5=0.8).

one needs to manually reduce the set of possible candidates by more than half of all methods until chance is as good as our prediction models in terms of retrieving a bug-prone method.


Therefore, the CQCE Method can check any test that may be formulated in terms of such a goal.

it is suited to perform all tests we have defined in this paper.


The cosine angle between two row ' vectors of Xre.ect the similarity between two terms.

''T XX M = 2 IX'I Similarly, two documents can be compared by the angle be ' tween the column vectors of X.


We typically learn Euclidean geometry to introduce the notion of proof, but by the time we want to calculate anything, we ve usually moved on to Cartesian, analytic geometry.

a circle isn t a curve: it s an equation.


A potential drawback is the increased cost of off-chip accesses as compared to interprocessor communication.

multiple processors can try to use the same set of buses/pins to go off-chip, and this can put a high pressure on memory subsystem.


We found that the models were from the project manager s perspective mainly seen as support for the requirements; specification models were used to provide structure to the requirements or to provide them with a context.

the simulation models were used to explore possible algorithmic solutions in order to learn to understand what the detailed requirements were.


Second, a meta-pattern that is common in the two classes, but whose attached performance metrics are signi.cantly higher in the slow class, also implies highly suspicious and high-impact runtime behaviors to the performance.

for the common metapattern Ps in the slow class, and Pf in the fast class, when- Ps.C Pf .C Tslow ever / > , the causality analysis selects the Ps.N Pf .N Tf ast meta-pattern as a contrast.


To simplify the presentation of the subtyping rules we introduce the speci.cationof operation for classes.

a lookup function that, given a class name C, returns a replaceable declaration righthand side that characterizes the set of methods of C. DEFINITION 2.3.


V(G)is given a bit-string O(G, u)corresponding to the advice given by the oracle O to node u about the network, this oracle takes in particular the edges weights of G in input.

in this model, there is a straightforward (.log n.,0)advising scheme (O,A) for MST in which each node is given by O the rank of the edge leading to the root of some MST T. for an edge e incident to u .


These are a very di.erent form of metadata from the valuebased examples.

the on-line reasoning required to deal with such functional description metadata requires more complex logic than may be the case for valuebased metadata.


While these approaches areoftendescribed as network virtualization ,butinthe broader systems literature, virtualization refers to the act of decoupling the(logical) service from its(physical) realization.

the virtualized service may be implementedby asinglephysical componentsharedby multiplevirtualized services or byusing multiplephysicalresourcestoimplement a single logical service.


Among these systems, embedded systems are more and more important in aeronautics, on aircrafts such as Airbus A320, A340, A380 or Boeing 777.


To handle this situation, we leverage the idea of an option type by providing a Forest-level Maybe type constructor that maps the optional .le system object to a Maybe type in Haskell.

if T is a Forest type, then Maybe T is the Forest type denoting an optional T. The type Maybe T succeeds and returns representation None when the current path does not exist in the .le system.


One way to do this is to compute the whole dynamic of S and to control it using the previous method, but this would leadto a state space explosion.Instead, we will use the contracts of the sub-components as an abstraction of them.Thus, we use an abstracted STS S , de.ned as the composition of S ' with the system part of the subcontracts, constrained with the properties enforced by Ki on each of the sub-components.

we take the assume and enforced parts of the subcontracts as environment model of the abstracted system.


Furthermore, our system does not constrain a method permanently to either Javastyle or Beta-style re.nement.

a derived class may use a different style of method overriding from its super class.


l ' : thus data Alice endorses can .ow to the database, but not data Carl endorses.5 Our resource reclamation scheme is, in fact, an information .ow control scheme which enforces an integrity policy: principals correspond to resource containers, labels correspond to sets of reachable containers, and endorsement corresponds to a copy operation.

the CM Monad is merely a type-specialized version of an existing, publicly-available information .ow control monad called LIO [23].


Finally, how do we minimize and report guidance on overhead in a way that can help users?

how do we accurately predict the overheard of arbitrary instrumentation?


It is our contention that thus far, the community has focused too much on data publication and failed to incentive massive adoption of the LD paradigm much beyond scienti.c computing.

lD has not yet demonstrated its value in business domain wherein Big Data has already attracted strong interests.


Because of the structure of network-based space layouts, graph algorithms are the natural choice for experimentation with query processing methods.

graph traversals are important for low level processing [11].


Moreover, there is no closed term of type B, since there is no closed .-value of type B.

b is neither inhabited nor provably uninhabited inside the logic.


The root cause of the di.erence is the join point model: what DominoJ adopts is the point-in-time model while the one AspectJ adopts is the region-in-time model [15].

in AspectJ the arrays of the three types of advices are separate, but in DominoJ there is only one array.


We assume that architecting an Internetware entity is based on extending the model of the autonomic element which can be viewed as the building block for autonomic systems.

if autonomic elements are extended to be self-adaptive and cooperative, the system created by means of nesting them is naturally equipped with the same features.


The mass observable relation is often assumed to be lognormal about a power-law mean.

a signal can be expected to be related to the true mass correctly on average, but has some scatter about the true mass value.


The future harvest is predicted using these two smoothed values and the cloud cover forecast.

the prediction for slot s of day d + k (k > 0) is calculated through h h µ¯d,s µ d+k,s = M · e d+k,s .


The QUEST_BODY must be structured according to commonality 3 and variabilities 1 and 4.

the block consists of a sequence of possible responses.


Therefore, missing con.rmation bias developers, who created and/or updated a source code .le, automatically implies that con.rmation bias metrics for the developer group of that .le are completely missing.

the entry in the data set corresponding to that .le is completely missing.


t Figure 3: A-posteriori abstraction With this in mind we introduce another building block of our calculus: in order to allow it to express sealing directly, we generalize coercion expressions to arbitrary types and make the transformation rules from .gure 3 built-in by turning them into reduction rules.

coercions will have the actual form '± {e : t }.


In this paper, we focus on handling partial page updates and aim at prolonging the lifetime and improving write performance for .ash memory.

we target at SSD, which is one of the most important and promising embedded devices in modern storage systems.


Another basic assumption is that the hosts present in the system cooperate to deliver the message.

i do not consider the case of hosts that may refuse to deliver a message or that act in a Byzantine manner.


Possible values are useful for universal properties, while de.nite values are related to existential properties.

the above bag relation can be simpli.ed to {2}.a$ .


MISCONCEPTIONS ABOUT MOCKS What we mean by "Mock Objects" is often different from what other people mean, and different from what we used to mean.

5.1 Mocks are just Stubs Stubs are dummy implementations of production code that return canned results.


The other use of regions is to control the extent of array computations.

for example, by prefixing the repeatstatement with [R] we specify that all array computations in the statement are to be performed on indices from R. the operations of the two assignment statements in the body of the repeat and the loop condition test, all of which involve expressions whose operands are arrays, will be performed on the n2 values whose indices are given in the region R. In this way programmers have global (declarative) control over which parts of arrays are operated upon.


As another example, the third pair (# 3) of code snippets have difference in variable naming, which is a local inconsistency within the clones themselves.

the if condition performs a NULL check on l_stride,but r_stride is used within the if statement in Code 2.


Entropy and Software Systems: Towards an Information-Theoretic Foundation of Software Testing Linmin Yang, Zhe Dang, Thomas R. Fischer, Min Sik Kim and Li Tan School of Electrical Engineering and Computer Science Washington State University, Pullman, WA 99164, USA {lyang1, zdang, .scher, msk}@eecs.wsu.edu, litan@tricity.wsu.edu ABSTRACT We integrate information theory into software testing.

we use entropy in information theory to measure the amount of uncertainty in a software system before it is fully tested, and we show how the amount decreases when we test the system.


To extend a pattern functor with a case for metavariables, it is, in essence, enough to introduce a sum to encode the choice between the extra metavariable case and a value from the original pattern functor: type Ext f = K MetaVar :+:f However, Ext extends a type with metavariables on the top-level only, whereas ee also have to allow metavariables to occur in subterms.

the pattern functor has to be extended recursively.


This problem can be minimized if the scope of phase detection is reduced from looking for global phase changes to phase changes within a small code region.

phase detection will be looking for working set changes within a bounded region and not the whole program.


Although Hoogendijk [19] coins the term parametric polytypism (for what we call parametric datatypegenericity ), and contrasts it with ad hoc polytypism , the only hont he considers is the generic ZIP described above.

although Hoogendijk certainly makes use of FOLD, there is no evidence from his writing that he realised that it too was a hont.


In the following instruction set speci.cation an IR addition (ADDP4) can be computed using either the instruction ADD .L1,or ADD .L2 in TI-C62x notation.

an addition can be performed using the functional unit L1 or L2.


Presenting functional abstraction and higher-order functions Both editions of How to Design Programs include sections on simplifying and generalizing code.

the book shows how to combine two similar functions into one by abstracting over the parts that are different.


It first confirms the speculation that the download request distribution is not even but influenced by user behaviors.

there are 476 items which have never been finished by any users except their publishers.


2C is the set of change-sets that the given commit follows.

it is the entire change history of the project from the start up to the given commit.


We only consider executions in which the invocation of a boundary method does not leave Cls that is, all of its transitive callees are also in Cls.

if we consider the possibility of unknown subclasses, all instance calls from Cls could potentially be redirected to unknown external code that may a.ect the composition inference.


5) MPI_WIN_IFENCE entails a barrier semantics wherever MPI_WIN_FENCE does, that is, whenever the fence call ends an epoch.

if a call to MPI_WIN_IFENCE must close epoch Ek and open epoch Ek+1, the progress engine of each process must internally delay activating Ek+1 until it receives the Ek completion noti.cations from all the other peers encompassed by the RMA window.


N and for all t = 0 mj Jmj ( j)t mj mj mj ||x¯(t) - e x¯(0)||2 = .j (t)||x¯(0) - x¯(0)||2.

i 0 i 0 there exists a zero-input solution that satis.es the above inequality with initial values x¯m0,k j (0), for k = 1, 2, .


6.1 Constraint Expressions and Lists Constraint lists are generalised in order to carry not only the constraints given in the de.nition of a constrained type, but also the constraints arising from its application to other constrained types.

constraint lists are also constructed from polytypic applications and they contain not only constraint expressions but also other constraint lists.


When higher-level specifications, especially task models, are available (as in [5]), these specifications must be used to refine the splitting process.

the temporal relationships between tasks must be used, which is not the case in [7].


Consequently, we have that in each state every label of the PLTS alphabet is enabled, proscribed or undefined.

the following equation holds for each state s: a(P) = enabled(s) .


For example, while performing tasks, users might realize that they must refer to other documents to perform tasks, or they might find that some documents are not necessary yet.

workspace construction is not a one-time procedure that occurs only at the initial setup of tasks.


In particular, we are interested in ADT de.nitions that depend more heavily on polymorphic recursion such as non-uniform ADTs, generalized and extended abstract data types (GADTs and EADTs).

for dealing with non-uniform ADTs we would like to consider an execution strategy that does not apply the problematic rules exhaustively, but rather lazy or on demand.


Indeed, we formally de.ne privacy properties through observational equivalence, however, ProVerif adopts a stronger equivalence relation called di.-equivalence.

di.equivalence can distinguish between the execution of di.erentbranches of a conditional statement evenin thefollowing case: if a = a then P else P /di.


Thus, a side effect of using filters is that they also eliminate some true traces.

using a filter reduces the number of false positives but it introduces false negatives.


Scenarios, depicted using variants of sequence diagrams, are a popular means to specify the inter-object behavior of systems (see, e.g., [5]), are included in the UML standard, and are supported by many modeling tools.

we are interested in modal scenarios presented using a UML2 compliant variant of Damm and Harel s Live Sequence Charts (LSC) [3, 7], which extends the partial order semantics of sequence diagrams with universal and existential modalities and allows symbolic class level lifelines, resulting in compact andexpressive speci.cations.


Furthermore, synchronization with a graphical editor is not based on any form of model merging because models are directly edited without the need for a generated parser.

it makes this possible for text editors to utilize the same underlying model as graphics-oriented tools.


As of February 2010, Programmableweb.com has published more than 4,700 web mashups developed by a number of end-users.

there are three mashups deployed every day on average, which is a rather rapid growth in any metric.


In terms of application failure, the window size is decided by job execution time.

all the events occurring between the job start time and the fatal event time are covered in the time window.


The abstractions yield by that technique feature an abstract time transition when for every state represented by the source abstract state there exists an amount of time to elapse and thus change to a state which maps to the target of the abstract transition.

it works as an existential elimination of the parameter value.


Also, one can exploit sparsity of relevant edge labels.

since typically relatively few di.erent kinds of edge labels in the graph are relevant to a query, the graph can be compacted by eliminating and collapsing certain edges and vertices before solving the query.


While these projects necessarily include some analysis of the programs, they are not designed for use as an analysis writing platform.

finally, RIL s design was in.uenced by the C Intermediate language [12], a project with similar goals for C. the authors prior experience using CIL s visitor class, and CIL s clean separation of side-effect expressions from statements, lead to a similar design in RIL.


Not every object allocation site creates a single run-time ob ject.

if an allocation site is inside a method that could be executed multiple times (i.e., a method that is reachable along multiple executions paths from the start method), it potentially creates multiple objects and cannot be considered as the source of receiver objects for singleton call sites.


In particular, we showed that a signi.cant number of paths to Ono-recommended peers crosses one or more ASes, but the average number of AS hops for these paths is nevertheless much lower than the corresponding number for paths from unbiased BitTorrent.

a pure AS-based approach cannot achieve the reduction in cross-ISP traf.c that Ono provides in the area between the curves where x>0 in Fig.


The ideas are the same, but the concrete representations are slightly different to make them practically more expressive and ef.cient.

disjunction and negation are added here.


By de.nition, the scale is a ratio-based measurement.


The get function is blocking when there are not enough elements in the buffer and the put function is blocking when trying to add more items than there is space in the buffer.

get does not return until the requested number of data items are available in the buffer, Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for pro.t or commercial advantage and that copies bear this notice and the full citation on the .rst page.


to mean pointwise inclusion, intersection, and union.

if A and B are indexed sets, we will write A .


To start, there are solutions for very small pi.

taking pi =1 for all i, insolvability requires that emax < 1 |.i -.j| 4 for some pair i,j.


However, their scheme does not address the issue of integrity discussed in this paper.

there is no way for a subscriber to verify that no malicious intermediate node added an encrypted share multiple times to change the value of the sum.


This follows because of semantic parametricity (sometimes called theorems for free ), which ensures universally quanti.ed functions satisfy certain properties (Reynolds 1983; Wadler 1989).


RELATED WORK Deferred preemption enhances predictability, simplifying static analysis [7].

.xed non-preemptive regions simplify CRPD analysis [12, 4].


This pMOEA paradigm is quite simple to implement and its search space exploration is con- ceptually identical to that of an MOEA executing on a serial processor.

the number of processors being used is independent of what solutions are evaluated, except for the pMOEA's reduced time.


As new equipment is purchased, .le servers may be added and used without bringing the system down.

each of these abstractions are failure coherent.the loss of a storage device yields a partial, usable, system.


The termination proof is non-trivial and relies on the so-called bar induction principle.

in.nite products N of quanti.ers cannot be computed with sequence or ,asalso shown in [8], with a continuity argument.


As a consequence, the content of some memory cell at a given step in the execution of a program may differ across runs.

the answer to the data.ow question, which operation wrote last into x may be different.


Otherwise, although there are user event handlers that execute in between a request and the corresponding response, the interleavings do not have any e.ect.

the interleaved execution is equivalent to the one without any interleavings.


This format contains a very weak soft constraint that is always false.

its isa returns 0.9998, which is high enough that no warnings appear at runtime (since, by default, tools are configured to display warnings only when isa returns less than 0.9).


This further implies that, if the data from these two regions were mapped to di.erent cache banks, remote accesses would be introduced.

|ih(ia -iaj )| re.ects the number of remote accesses that could be introduced by this partitioning (under the hyperplane h) when considering the reference pair ia and iaj , while Cost(ih) predicts the total communication brought by this partitioning when considering all the reference pairs in the loop nest.


More importantly, however, we do not propose to change the business model.

developers will still be able to write source code in plain text and compilers will still read plain text as input.


The language consists in offering a programmatic means to use key concepts to specify design defects.

it provides the concepts of rules, rule cards which are sets of rules combined using set operators, and properties related to the lexicon, the metrics and the structure of the design.


Hence, software testing should be incorporated with the FTL and file system development from the very start.

once the software is initially designed and implemented, it goes through a thorough testing phase, in which design flaws and incorrect implementations are detected.


We do not provide such advice, except insofar as it can be simulated with a matched pair of before and after advice.

there is no ability to control or prevent execution of a line, as with AspectJ s proceed keyword.


2.3 Model-Driven Development Model-driven development (MDD) aims at shifting the focus of software development from code to models.

mDD promotes tackling software complexity by raising the abstraction level of software systems to a higher level than code, closer to concepts from the application domain than to algorithmic concepts.


Assume that the probability of block corruption is Err =0.01.


The three extensions we propose allow the user to de.ne interesting extra-logical structures.

our propositions are predicate symbols, and our type functions like plus on kind Nat are function symbols in the logic.


This is done by annotating process-driven model instances with the compliance meta-data.

we elaborate on how to express compliance requirements originating from some compliance documents for process-driven SOAs using the VbMF.


Furthermore, applying a captured delimited continuation should install its exception handlers in the context of the current handlers.

installing a delimited continuation has the effect of splicing together two sets of handlers.


INTRODUCTION A standard block cipher G is a family of permutations controlled by a family of keys.


Modeling CORRELATION IDENTIFIERS solely in the components & connectors view of the PROCESS-BASED INTEGRATION ARCHITECTURE creates one more inconsistency with the Process Flow view.

the macro.ow and micro.ow models should pass a valid CORRELATION IDENTIFIER type to all asynchronous invocations.


In [21] the authors use standard Java portal technology to implement the graphical interface.


This amounts to the requirement that the memory locations the representation function operates on are not manipulated outside of ADT operations.

(these locations are neither read nor written by transitions not corresponding to operations of the ADT.)


ß. a2N12..Nk2 2 = ··· =G(am)N1 m..Nkm m .

ß. aM1..Mn the derivation is started with S-id and followed by alternative applications of S-G and SA-ß.. Then, we show that there should be at least one ai in this sequence such that ai occurs before a in the context G. Finally, by induction on the position of a in the context G, it is proved that such a sequence can never be constructed.


(t,t,...,t); 1 2 K task instance to utilize the energy saving in the dormant mode.

if the worst-case execution time of the task is w<p, we would let the processor stay in the dormant mode until the current task instance has been released for p -w time units so that the energy consumption in the p -w time units for procrastination is 0.


This is the purpose of the product operation: A × B = (A # B) + A + B .

when architects want features A and B, they also want both features to work correctly together, which requires the addition (composition) of A and B with their interaction resolution A#B.


It can then treat each subgraph as if it were a separate static application, using a static data-parallelism scheduler.

within a subgraph, operators communicate through static bu.ers, and the compiler can statically optimize each subgraph independently of the rest of the application.