Under the translation they become the contextually inequivalent expressions let val x = ref () val y = ref () in ((x ,x ),(y ,y )) end, let val x = ref () in ((x ,x ),(x ,x )) end which are distinguished in ML+swap by the context let val x= [ ] in #1(#1(x)) = #1(#2(x)) end (where #1 and #2 are ML notation for .rst and second projection functions).

it might seem then that we could better mimic (name)t in ML+swap with an abstract type with underlying representation name × t. being abstract, we would lose the Concreteness property mentioned in the Introduction, i.e.


In this paper we focus on uniprocessor support where the degree of interleaving of execution and non-determinism can be controlled.

even on a uniprocessor there is some remaining concurrency resulting from asynchronous I/O devices.


Examples of corresponding systems are Borealis [3] and Cayuga [11].

most work considers events to be unicast, or focuses on individual processes and centralized setups in attempt to provide best-effort guarantees.


This di.erence highlights the impact a poor initial deployment has on QoS.

it also demonstrates our middleware s capability to dynamically adapt to QoS degradation.


ond s metadata processing power, which makes them a suitable solution to address lots of applications I/O needs.

with the popularization of internet applications and extensive applications of high-end scienti.c computing, cluster storage is now facing with the big challenge caused by many more .les and data to be stored in the .le system.


Our results show that, with the proposed branch selection algorithms, a DMP processor outperforms an aggressive baseline processor by 20.4%.

the best-performing alternative branch selection algorithm results in a performance increase of only 4.5% over the baseline.


The PIMD server is allowed to relocate records if, despite hashed distribution, a node becomes overloaded.

such relocation should preserve hash locality by bumping records to nodes that are nearby in the network topology.


Generally, these concerns lead to pages that are larger than optimal for reference update tracking, typically at least 4 Kbytes.

the card size of ResearchVM is 512 bytes.


), 1 In formal de.nitions, to distinguish the bind and return operation for says monad from those for pf monad, we annotate the bind and return with a subscript s for says monad and p for pf monad.

the type checker can easily tell them apart; therefore, in AURA programs, bind and return are overloaded for both monads.


The typical solution proposed in [19] is to inherit from an abstract aspect and to provide the advice code referring to the inherited pointcuts.

we have chosen to use the design principle of favoring composition instead of inheritance, taken from object-oriented design [15].


This means that many base languages can be made extensible by instantiating Sugar*.

for extension modules we are currently much more restrictive.


The idea is that the checker has to explore the space of possible instances and look for such a counterexample.

since the solution space is infinite, it reduces the exploration to a finite set of canonical instances, each representing a fraction of the solution space.


By combining existing components in a loosely-coupled architecture, applications delivering signi.cant functionality in a scalable manner can be quickly created.

the assembly, installation, and management of such systems in a consistent and e.ective way is currently a di.cult and resource-intensive problem.


We did not have to resolve these con.icts because the callbacks execute only when the gestures are completed and none of the gestures are identical.

such analysis could be useful when designing a new unistroke command to check that each gesture is unique.


The media access in star topology of IEEE 802.15.4 is contention based.

using the optional superframe structure, time slots can be allocated by the PAN coordinator to the devices with time critical data.


By converting feature models into ontology models, the authors provide a foundation for different mechanisms to validate feature models through ontology inference.

one of the core problems is to agree on a common description language to describe features of potentially similar assets, using heterogeneous terminologies.


However, these methods can only enforce coarse-grained access control policies which are not applicable to untrusted script scenarios.

approaches to enforcing security policies without modifying browser have advantage in themselves.


The experimental results show that the JDSM generally scales well on different platforms, demonstrating the viability of portable implementation.

we do observe that there are some overhead incurred in the synchronization, resulting in load imbalances and increased execution time.


Different programming languages and platforms would have different sets of transformations.

a patch program uses diff outputs to transform a program, but it is designed to work with a single version of a program.


as the values needed by t0 of k2 have been loaded into the SRF by the built node t0 of k1, a reference edge is inserted from the built node t0 to k2.


of FLAT, which allows parallel execution utilizing embedded MPI, is accomplished.

the execution time is much longer than the traditional implementation.


For tc_sound the situation is particularly bad, with NE 15-20 times slower than NF or NE-.

for the tc_prog checks, both NEbased techniques are faster.


A variety of mobile transaction models (e.g., [3, 13, 14]) have been proposed, which are able to cope with failures due to frequent disconnections.

they share with ATMs that they are statically speci.ed and limit themselves to veri.cation at runtime.


BLCR can either save the snapshot of a native process on Xeon Phi to the host s .le system through Network File System (NFS), or to Xeon Phi s own local .le system.

both of these two storage choices have limitations.


The best covering arrays often do as well.

covering array generators do not ensure that alias free designs are generated, nor do they attempt explicitly to obtain the best covering variance.


In a similar way, one can see that also q must be in P .

our source set-based algorithms allow S = {p, q}as the set of processes explored from the initial state.


This means that there is some type assumption in some Gi which is not satis.ed by the types of other fragments.

this does not necessarily mean that the fragments cannot be safely linked.


Using the scheme in Figure 1 implies we are evaluating the models being selected by the model error, i.e., we evaluate both the suitability of the model shape (e.g., linear, geometric) and the relevance of the independent variables.

this is not sufficient to come up with a correct evaluation.


Middleware services encapsulate highly efficient algorithms and design patterns that are generally superior to the ad-hoc solutions implemented by application programmers.

middleware adds an additional layer of abstraction to the computing stack, which incurs additional overhead.


In the planning game, user stories are created that determine functionality; increments are based on these stories.

in HIS, the minimum size of system that needs to be built before a verifiably (and certifiably) safe design has been reached may be very large.


fields are not statically assigned to forms by the data layer.


For example, new methods were included within the ScenariumServiceProxy class in the OC framework, as illustrated in Figure 3 (lines 03-12).

the changes included in the framework code should have only been performed in Application I since they are related to member-specific code.


Likewise, smooth formalizations for data bind ings can be found for functional programming languages, like Haskell [15, 2].

the data bindings for objectoriented programming languages su.er from an impedance mismatch [11].


This is because when the number of cores is small, the load imbalance across them is more signi.cant.

with a larger number of cores, trying to balance the workloads may not be as effective.


As an intellectual tool for language designers, a strength of the Attention Investment model is its generality, which allows it to provide insights not produced by the more speci.c CD framework.

the concrete enumeration of issues in CDs is more prescriptive of speci.c problems to consider, and provides sharper questions for language designers.


The code generation scheme in [7] is relatively simple and operates at basic block level and relies entirely on Llvm standard optimisations.

our simulator operates on trace regions and adds partial evaluation on top of standard code optimisations, thus providing higher performance without manual user intervention.


Providing this environment was critical to make the system work in another development organization.

shape management also discovered that it was important to share their technical expertise along with their system.


Thus, trading of .owers and trading of fruit is mapped to Timewarp.

the transfer of real money is considered to be a critical action with high consistencyrequirements where no inconsistencies are tolerable.


This method embeds data by changing the LSB values of the quantized DCT coe.cients.

this method can be easily detected by estimating the shape of the histogram of the modi.ed DCT coe.cients.


It is therefore important to assign requirements according to stakeholders familiarities at the same time keeping the balance of each stakeholder s workload.

such a manual approach does not scale when the number of requirements and stakeholders is large, which is often the case for large-scale applications.


This step mainly confirmed the results from the chi-squared test.

for the relationship between factors and roles, this test highlighted some factors that we have decided to manually analyze.


However, embedded systems have been physically protected from massive security threats to such an extent that security attributes like con.dentiality, integrity, and availability have hardly been regarded as a central feature in the design of such systems.

security engineering approaches for embedded systems can build on a large body of work in IT Security.


Static binary translation can also afford more aggressive optimizations since optimizations are performed of.ine.

a static binary translator may suffer from two main problems: the code discovery problem and the code location problem.


This means that developers not only need to reengineer their grammars with TypeChef s combinators but also have to correctly employ the various join combinators.

mAPR s tabledriven LR parser engine automates both forking and merging.


Ca  C = pNone Ca  C ' = Ca if C = C '  6.3 Implementation We have not yet actually given a complete implementation of the assertion combinators for constructor terms.

the laws of our lemmas and the general distributive lattice laws are suf.cient to derive an ef.cient implementation.


Indeed, the application and collaboration level models of our approach can be viewed as speci.c and generic PIMs (platform-independent models), while middleware-level models can be viewed as PSMs (platform-speci.c models).

there is a main di.erence between our approach and MDA: in MDA, models and transformations are used at design time, while our approach uses models and transformation as a run-time adaptation to context changes.


The parameter a, the fraction of nodes needed, gives a way to analyze the total churn experienced by all users: we can take a to be the utilization of the distributed system as a whole.

our results do not address fairness between users, which we leave to future work.


In turn, this corroborates our assertion in Section 6.2 that FUSION produces a stable fix to goal violations by placing the system in a nearoptimal configuration.

since CS may find borderline solutions that barely satisfy the goals, due to slight fluctuations in the system, goals may be violated and thus frequent adaptations of the system ensue.


The intended use of the XOP is to act as a proxy for an XMPP client located on the same machine.

it is designed such that it could be used as a proxy for several di.erent clients, so several applications on a node could all use XMPP for communications and share the same XOP instance.


As these properties are always domain-and transformation-speci.c, it is hard to quantify what it costs to satisfy them.

we believe it is feasible to integrate such checks into practical transformation applications and, if the speci.cations are indeed independently developed, they could serve a solid foundation for verifying the results of transformations.


So, monads seem to implement aspects by mere functional composition.

this is not entirely true because in order to bene.t from the improved composition possibilities provided by monads, programs need to be written in monadic style.


Data transfer state is recorded in a database; when a transfer fails, it can be restarted automatically by using the persistent data.

our system supports not only third-party transfers but also client-server transfers.


By contrast, Steno attempts to optimize the execution of explicit queries.

since XJ supports LINQ-like query syntax, it may be possible to apply this analysis to C# programs, and identify opportunities for common subexpression evaluation between Steno-optimized queries.


portlet preferences) and user pro.le parameters whose values are provided by the portal at runtime.

the Consumer Pro.le frequently implies extensions on new markups, controllers or persistent data that would be very cumbersome to develop and, most important, maintain from a single block of code using adaptability approaches to custom dynamically the code to the current pro.le.


The use of model transformation (MT) techniques for the implementation of semantic mappings has already been suggested in, e.g., [8] where the use of the a speci.c MT language (UMT of the GReAT tool) is advocated for this purpose.

we see the implementation of the semantic mapping as an excellent case study for the comparison of different MT approaches and languages, because the transformation task is described unambiguously.


Now suppose that some time later, we bring two additional servers C and D online, and re-balance the load using the last two bits of the IP address, directing traf.c from hosts whose addresses end in 00 to A, 01 to B, 10 to C, and 11 to D. Intuitively, we want to process packets from new TCP connections according to the new con.guration.

to avoid disrupting applications, it is important that all packets in existing .ows should go to the same server, where a .ow is a sequence of packets with related header .elds not separated by more than n seconds, and the particular value of n depends upon the speci.c protocol and application.


We believe that it is often dif.cult to come up with effective functional correctness assertions.

it is often quite easy to use bridge assertions to specify deterministic behavior, enabling a programmer to check for harmful concurrency bugs.


no existing tool supports a security requirements engineering approach.


Some of them demonstrate how their profiles can be mapped into the Web Service Description Language (WSDL) such as [7] and [5].

they do not provide any editors for modeling or code generation facilities.


Due to its heavy communication with small messages, POP does not scale on EC2, as can be seen from Figure 5.

its I/O behavior is still representative in parallel applications.


Our notion of harmless advice is similar to their notion of observers  observers do not interfere with the mainline computation.

the details of our type and effect system are entirely different from their Hoare logic.


The RTSJ specification concentrates on adding predictability to JVM thread operations, but does not aim to deal with memory footprint, performance, or interrupt  latency.

the Core specification has been designed to optimize on performance, footprint and latency.


Since children need to only narrate a story to an artist, little accommodation is needed on that dimension (2).

determination of the need for accommodation spectrum also depends on the context of a research project.


For example, if a target optimization is to lazily allocate non-accessed objects, the objects allocated at a site that has allocated some or many non-accessed objects should be sampled frequently to carefully assess whether or not it is worth delaying object creation at this site.

the objects allocated at a site that has always allocated accessed objects can be sampled less frequently, although the sampling should not be completely disabled to adapt to dynamic behavior changes.


To avoid weakening the semantic connota- tion of the exception, it should not be propagated past the client compar~ent This is not to say that abstract exceptions should not necessarily be reused where appropriate.

the use of abstract exceptions should be limited to compartment boundaries.


9 Conclusions Atomicity signi.cantly facilitates the validation of multithreaded programs, since each atomic method can be considered to execute sequentially.

verifying atomicity properties in large programs is non-trivial.


PERFORMANCE EVALUATION 5.1 Simulation Details We have performed several simulations to evaluate the Surework approach.

due to space limitations, the conclusions presented in this paper are only a subset of the obtained results.


Figure 1 BlueGene/L Log Messages Commercial applications such as Google s search engine experience an interpolated fault rate of just over one hour for an implementation distributed on an a number of nodes equivalent to those found in petaflop machines.

google s faulttolerant middleware disguises these failures from the customer while successfully maintaining service [4].


Changes to private members, for example, are always source compatible, since no other top-level classes can reference such members2 .

a source incompatible change may (though not necessarily will in each particular case) break the contract between a class and some of its dependent classes.


It might seem to be straightforward to equally de.ne the dynamic type of a CR.

we decided to call the dynamic type of the tail the temporary type of a CR, because this type may change as a side e.ect of a .eld update.


This is exactly the property we have put to good use with the de.nition of heuristics over search trees.

handlers like our heuristics are akin to a shallow embedding of a DSL: they can be used in one way only, by function application to a computation.


For example, the following code canbe used toleak con.icting-reviewinformation: leakingRetriveReview r = do rv .

retrieveReview r if rv == "Paper..." then forever (return rv) else return rv using clearance,wepreventsuchleaksby setting the clearance and review labels in such manner that retrieveReview fails when raising the computation label to retrieve con.icting reviews.


In particular, the framed audio is converted to row vectors of size 16 kHz × 50 ms = 800 for subsequent processing, which are stored in the data memory for maximum .exibility: Any component can use the framed audio to apply its own processing steps.

the video source is implemented 3http://opensmile.sourceforge.net/ in a monolithic fashion which does not involve storing the results of intermediate processing steps, such as conversion to grey scale, etc., for e.ciency reasons.


A wide bound (e.g., [0.2, 1]) suggests the current degree of sampling is insu.cient, resulting in the large uncertainty about the target s trustworthiness.

a narrow bound (e.g., [0.85, 0.9]) indicates diminishing returns for further sampling.


One may object that a solver should not just produce a Boolean answer, but also transform a constraint C into an equivalent solved form.

if the term t is closed, then the constraint [t : a]has just one free type variable, namely a.


Ideally, we want to correlate systems-level quantities that can be easily measured with user study results in order to validate the latter.

this is often di.cult, if not impossible, due to the considerable variation in user responses.


Most studies consider unit tests and measure the effectiveness and reliability based on their ability to fail due to code issues.

test failures due to other reasons than code issues are likely to impact product development and thus should be considered harmful and taken into account when measuring test quality.


For general iterators, loop unrolling with index substitution cannot be used in Python.

consider for example the loop: def f(bar): sum = 0 for p in bar: sum += p Though nothing is known about the literal bar, general unrolling is possible as follows: def f(bar): sum = 0 it = bar.__iter__() try: while(1): p = it.next() sum += p p = it.next() sum += p p = it.next() sum += p p = it.next() sum += p Except StopIteration: pass # resume direct index substitution of the following form may not be possible unless it is known that sum and p1,p2,p3,p4 are not dependent on one another (e.g, affected by some change of the iterator application).


A recent update of the Gartner Hype Cycle [14] highlights the importance of the IoT, and indicates that the idea of an IoT is no longer as fictive as it might have been regarded in the past.

in order for the IoT to really take off, end-users need to participate in the creation process on a larger scale.


As process maturity increases, the belief is that product quality will improve as well.

the ability to independently assess product quality directly, irrespective of the process used to create it, would be very valuable in helping determining overall documentation quality.


Valuable work in the Literature, such as OASIS [9] and SeCSE [7], propose reference models for achieving a common understanding of the SOA style.

these models do not specify how the service-oriented interaction pattern should be supported at runtime.


[17] introduce a language feature called implicit parameters that provides dynamically scoped variables for languages with Hindley-Milner type systems, and formalize it with an axiomatic semantics.

functions with implicit parameters are not .rst-class values in their setting.


Similar resource abstractions have been proposed earlier over grid systems [16, 18].

vgES has the (a) Example Workflow Set  need F=2/3 Batch Queue Figure 3: Interaction of system components for resource pro curement and planning slack in the schedule to replicate the second work.ow in Figure 2a for fault tolerance.


Because copying garbage collectors move objects, they have an opportunity to improve locality.

no static copying order is guaranteed to match program traversal orders.


A fairer comparison would have been with the MOS [14] algorithm, which is the most powerful deterministic algorithm known for this problem.

implementing this algorithm seems quite a bit more complicated than either of our algorithm or SRH.


ister assignment, and memory disambiguation.

their annotations are not safe and not veri.ed; therefore, their annotations cannot be used in environments where security is required.


The only consequence is that some logged variable values may be less useful for diagnosis or that we are still missing some causallyrelated variable values.

the recorded variable values are still valid, just as if programmers manually added those variables into logging statements.


Agile process models have been introduced to ensure more frequent and consistent alignment of business and technical stakeholder positions through continuous feedback cycles [7].

while agile process models encourage (and actually depend on) intensive communication, they typically do not provide explicit operational support for it.


INTRODUCTION Software engineering manages many kinds of documents that are related in many ways; it is the place for cross-cutting concerns and multi-view schemata.

this rich network of relationships is often .attened on a single hierarchy.


APFD metric used in our experiments is the only APFD metric designed particularly for time-aware test-case prioritization.


In the literature there are prediction models, which employ people related aspects, such as or ganizational complexity [23], developer experience [40], and social interaction among developers [3].

among people related aspects, the thought processes and problem solving skills of people also have a signi.cant impact on soft ware quality [29, 32].


In addition to the requirements of realtime voice communication, mobile phone di.ers from PCs in having unique restrictions such as limited resources in memory size, processing power and energy consumption.

existing VMMs do not address those issues completely.


We do not claim that our code is entirely free of bugs.

the tests that we have written check the basic functionality of our server and make us con.dent that any scenario that may occur in practice and has been covered by our tests will actually work as expected.


One criticism of the Asbro tool could be that what it can do can be better done with a query tool, such as Lost (Section 6.3 explains brie.y why we believe Lost is a representative query tool).

our results show that, on average, users of Asbro solve the examined tasks much faster than with Lost, and we .nd a speed up between 53% and 89%.


t. .ls : list t. let binary op = Monoid.binary op in let identity elt = Monoid.identity elt in if null[t](ls) then identity elt else binary op(car[t](ls), accum(cdr[t](ls))))) It would be more convenient to write binary op instead of the explicit member access: Monoid.binary op.

such a statement could be ambiguous without the incorporation of overloading.


A large number of cache misses are expected to occur at run time.

due to hardware prefetching, the real performance is better than the predicted because the accesses demonstrate a streaming pattern and the L2 cache MPKI is not as high as that of scimark..t.large.


A processing scheduling algorithm will pick a running process in a ready queue and gives it a CPU time slot on every time tick (20 ms typically).

should there is no process in the ready queue, and there is no running process in the running queue, the process scheduler will run an idle process in a typical implementation.


In comparison, our approach is less sophisticatedinthatit sayslittle abouthowprobability values are independently validated beyond providing individual rationale statements.

our approach does bene.t from the close relationship between obstacles and other model elements; these provide additional evidence for making claims about individual probability values.


AOP has, for instance, been applied with some success to pro.ling [6] and runtime veri.cation [1].

different domains have different needs, in particular in terms of the join-point model and, unfortunately, tracking information .ows requires to operate at a granularity level not covered by our off-the-shelf weaver for Java-Script, AspectScript.


Conditioning is typically viewed as a special operation that happens to a probabilistic model (capturing observations or assumptions), not one that can be expressed as a model.

because probabilistic programs allow stochastic recursion, conditioning can be de.ned as an ordinary probabilistic function (Fig.


The problem appears to be more di.cult in the framework we consider, because unlike the normal grid-computing framework considered in [14], we cannot use any method that requires that the server sees the answers it is computing.

whereas the fact that the remote servers do not see the answers they compute precludes the use of some techniques (like a Merkle tree built on top of the computed answers), it makes possible the use of other techniques that take advantage of the fact that the remote server does not see the answer: We will investigate techniques that facilitate the client s cheating-detection by exploiting the fact that the server sees neither the data nor the answers.


We thought this would make it easier for them to express their opinion.

some of the participants pointed out that they would have been able to express less biased opinions had they been assigned to a different role.


The SOA projects we researched were started either to solve systems integration issues, or to support Business Process Management (BPM) initiatives.

since the services developed in these workflows were only related to a small number of workflow steps confined to one business activity, governance was not perceived as an issue.


A concurrent program s inherent non-determinism makes it dif.cult to reason about and even harder to debug.

concurrency has proven to be a useful tool for structuring programs, as well as an important means of improving performance.


Using these functions, we can now create our example tree and attach agents to each node: ex =root$ do{ a <-new "a"; b <-new "b"; c <-new "c"; amb a (do amb b (into c); amb c nil)}  Here, the agent attached to b uses a new function into: into :: Name -> Agent The .gure treats the more general case when the agent performs other actions e after calling into.

for simplicity, it does not depict nil processes or back pointers to handles.


F is .nite, so we have a .xed number of constant symbols.

constant expressions such as 2 are allowed as an abbreviation for add(1, 1).


Semantic-Augmented Indexing One of the most important aims of execution indexing is to establish meaningful correspondence among points across multiple executions.

as correspondence is essentially a semantic concept.


Dynamic contract checking helps add additional runtime assertions to check, which can provide more observability at runtime.

checking user-de.ned contracts statically is not cost-e.ective beyond a speci.c class of properties (bu.er overruns, locking protocols).


Now, form the in.nite chain (t1,t2,...) consisting of si such that isContinue (terminate histi si).

by the properties of terminate, it follows that: .ij.j <i =.¬ (tagBag tj < tagBag ti) this contradicts the fact that < is a well-quasi-order.


The example above is somewhat naive since Structure 2 is consistently better than Structure 1.

the example illustrates that a good correlation between a column in the FAS and the PQA-vector is not a good criterion for identifying an architectural structure.


Hence, from security point of view it is a flexible and perfect approach.

nobody can deny the performance penalty which has always been the cost of providing security.


of testing program changes to make sure that the older programming still works with the new changes [2].

the test for wiki refactoring is whether the community ends up happy [1].


For example, software fuses (such as .rewalls) drop out-of-bounds inputs before they reach a vulnerable component; output guards detect apparent component failure and stop the suspect module, thus coercing Byzantine into fail-stop behavior.

candea's proposal assumes that misbehavior is apparent at either the input or the output of a component; system-wide (emergent) misbehavior might either be invisible at this level, or might be so pervasive that software fuses or guards would effectively shut down the entire system.


The percentage of matched keypoints increased as the largest randomly selected subset of Frame1 keypoints are scanned.

these Max values are considered optimistic in the case of various frames across 50 to 150 frames of video.


The readers may notice that the FSA in Figure 5 seems to be easier to inspect by software engineers because of its regularity and correspondence to the code.

the FSA before re.nement shown in Figure 5 is less precise than the re.ned FSA in Figure 6, and thus the FSA before re.nement is much less useful than the re.ned FSA for veri.cation and validation.


In particular, it is possible that I2 depends on I1, both have failed invariants, but I1 was actually a false positive while I2 was a true root cause.

we expect this behavior to be rare with suf.cient training.


This implies that, when considering L1 alone, we can store all arrays (V1 , V2 , and V3 ) in 6K RPM disks, which require 2N j loop iterations to schedule-ahead the disk access since the latency incurred by 6K RPM disks can be eliminated by choosing next surrounding loop nest, i.e., i loop as the pipeline loop.

since both arrays V1 and V2 are accessed again in nests L2 and L3 respectively, possible disk speeds for V1 and V2 arrays are also dependent on the L2 and L3 nests.


Our versions of Hybrid and Race-Fuzzer may report race siblings, and also Chord, Pacer, and Racageddon may report race siblings.

fastTrack and Goldilocks report only one of two siblings.


Looking at the highest measured con.guration on Jugene, the parallel creation of 256 K .les took approximately 33 min, which clearly demonstrates the scalability limits of using multiple task-local .les in parallel.

having 256 K tasks create a multi.le (16 physical .les) took only 8 s. On Jaguar, the time needed for the parallel creation strongly depends on how many OSTs have been chosen to stripe the .les across.


Their study on Eclipse and Mozilla found evolutionary couplings that were not represented by the source code dependencies they considered.

a software-change prediction approach that combines both IA and MSR techniques and their systematic evaluation is not reported in the published literature.


7.2 Relative Energy Model While the energy model equations from Section 7.1 capture basic properties of energy consumption, the models rely on several hardware design specific parameters, such as the average energy of instructions.

we can use these equations to derive a numerical optimization problem that instead uses cross-design parameters (such as the relative energy between instruction classes and the average savings for each instruction) to optimize energy consumption of the program relative to an exact configuration of the program, 0.


On the other hand, a sequence of recent warning reports may spur interest in a previously neglected .le.)

there is merit to other approaches, which future work could investigate.


Additionally, most studies measurelighteither at a singlepointintime or overperiods of minutes orhours.

thereis a need toquantifylightat .nertemporal scalesbecausephotosyntheticresponses occur within seconds and courser measurements oftenunderestimatetheeffectsofbrief,butintense,directlight.


With the new procedure, the analyst no longer has to compare scores or do other evaluations to choose a single score.

analysts may have to evaluate a few more cases than they otherwise would have.


In general, middleware are technologies aimed at supporting distributed applications by masking the distribution and heterogeneity of the execution and networking environment [8].

next generation pervasive networking environment, such as Beyond 3rd Generation (B3G) networks [12], can be no longer considered as passive entities which only transport data between end-points and, as such, they cannot be masked by an homogeneous layer.


By guaranteeing intersection only with high probability, probabilistic quorum systems (PQS) [9] overcome such fundamental limitation on availability and probe com v plexity.

the PQS construction in [9] still needs .


The answer will depend on whether one writer clearly dominates the other: if one writer doorway precedes the other, then the former should be able to enter the CS in a bounded number of its own steps.

if neither w ' nor w doorway precedes the other, neither process may be enabled ' to enter the CS; however, in this case, if both w and w keep taking steps, it is reasonable to require that one of the two will eventually enter the CS, regardless of how their steps interleave with the steps of other writers and readers.


In our application domain, we neither know all initial states nor can we compute all reachable states of the system.

we can inspect every transformation rule to .nd out whether it can transform a safe graph into an unsafe graph.


BXGrid could write changes to both database and storage servers at the same time.

because of the time discrepancy between a database update transaction and a disk write transaction, writing changes to both is lagged and bounded by slow disk speed.


Similar to us, they .nd that there sometimes is value for the workloads to share resources, rather than using separate resources for the two workloads.

focusing on a di.erent domain they are concerned with a quite di.erent service model and metrics.


There is a lot of marketing pressure to create such changes, and PPT was not immune to this pressure.

a review of current Enterprise Resource Planning (ERP) implementations in several companies shows a very high risk that benefits may be elusive.


4 and using the maximum state entropy (2), the single constraint p1 = 2 ·p2 would lead to the same result as the constraint p1 =2 ·p2 would do.

the customer expert, who formulated the constraint, probably had in mind p1 to be mostly bigger than twice the amount of p2 and to handle the equality only as a marginal value.


Second, a modi.edkernelcouldguaranteethat somedeferredcalls or compensatingactions cannotfail.This would relieve the programmer of writing error-handling code for these cases.

we believe that it is a bad practice for the kernel to promise that operations succeed, as it precludes future kernel modi.cations that introduce new failure modes.


For example, for conjunctive tasks, all group members must contribute to the solution, but for disjunctive tasks it suffices that one group member has the ability to complete the task.

it is not obvious what sort of task PP is in this respect.


Again we use the Avrora simulator for the evaluation.

since this simulator did not include the custom sensor interface board used by this application, we had to add its energy consumption to the simulator s energy model.


In our preliminary design [32], we showed how the con. dentiality and integrity of data can be protected by a cryptographic mechanism so that they can be stored in untrusted nodes of a DHT.

the design su.ers from performance issues that arise due to the fetching and decryption of hundreds of small objects belonging to friends, which is required for viewing their walls or for viewing one s own newsfeed.


both its NUMA and NUCA ratios are well below two.


The .rst one is done by transferring the block of vector elements on the global memory into a bu.er in the local memory, and then transferring them from this bu.er to the new destination address on the global memory.


However, in real distributed systems it is dif.cult to use synchronous design because of physical limitation such as communication delay or performance issues.

asynchronous systems are notoriously complex since theyhave to deal with potential message interleaving which does not exist in synchronous systems.


A crucial parameter at this point is the number of partitions in the reduce stage, which decides the number of reducers and thus the degree of parallelism, and is usually statically set to a large number so that scheduler can balance the workload [13, 19].

when the volume of data output by mappers is small, it is better to use a smaller number of partitions in the reduce stage, lowering scheduling overhead and disk I/O cost [13, 34]).


One way of precising one information within the cell is to provide this extra information between parentheses.

this pattern is also much used to express constraints or partial answers.


It is only if the service handles personal information, in the sense of collecting, transferring, processing, sharing or storing it, that there could be a privacy risk and privacy needs to be taken into account.

services that are dynamically personalized based on people s location, preferences, calendar and social networks, would require privacy to be taken into account a great deal, as the potential risk is high.


SSA graphs do not re.ect memory dependencies.

theydo have memory operations that impose data dependencies among memory operations including loads and stores.


Sucha reuni.cationphaseisinitiated, if all subpopulations have converged prematurely.

authors such as Alba and Troya [4] found that in the island model, the migration of a random string prevents the conquest e.ect in the target island for small or medium sized subpopulations; this could be explainedbytheimmigrantindividualbehavingas an intermediate disturbance, as opposed to the strong disturbance initiallyprovokedby thehigh-.tnessindividual.


X that satis.es all the equivalences a lens programmer would want.

tensor product does yield various symmetric monoidal categories of edit lenses; for lack of space we omit the details.


Casts on base values like integers and booleans are straightforward either the value is of the expected type, in which case the cast succeeds and the value is returned, or the value is not, in which case it fails.

casts on mutable values, such as lists, or higher-order values, such as functions and objects, are more complex.


To say the preceding is not to imply that the KAOS process is without solid formal underpinnings far from it.

sprinkled here and there, in [1] for example, one .nds comments that such-and-such an issue, ... requires more research or needs more detailed investigation .


This would make it easier to implement an approach such as ours directly on this parallel hardware on the CPU.

current-generation CPUs lack support for scatter and gather instructions, which would be crucial for such an approach.


Specifically related to the domain of patent documents, the PATEXPERT project has developed an ontology for the patent document domain which focuses on the European patent system [4], [5], [11].

the above mentioned methodologies focus on a single information silo, and hence are not applicable to a larger set of heterogeneous domains.


The column with header 1% represents the number of clusters in each category for the segmentation with a shift of 1% of the segment start and so on.

since the classes are heavily interacting to implement the use-cases we expect some inter-packages coupling.


If the minimum interarrival time (MIT) is T, then the profile assumes that D = T. This implies that the rate monotonic setup can be used for setting up the NoHeapRealtimeThread belonging to the SporadicEventHandler, together with the setup of the periodic threads.

in some situations it would be useful to define a deadline less than the MIT, D < T. In this case the rate monotonic setup could be replaced by a deadline monotonic setup [7, p. 484], defined by: Di  Pj , where P is the priority.


As the stack can hold pointer values, these loca- tions must be replaced with their replicas when the garbage collector is turned off.

the stack can be very deep and disrupt the desired time bounds.


Finally, the gains from increasing k and increasing r are in general subadditive.

one notable exception is THREADESCAPE on batik, where going from r =1 to r =2 when k =0 increases precision by only 0.5% whereas going from r =1 to r =2 when k = 8 increases precision by 75.6%.


While the implementation needed to adapt due to limited browser support, this approach successfully provided dynamic service discovery using a soon-to-be standardised mechanism.

dynamism is limited to the point of discovery: after a service is selected, changes to the local network will not a.ect the application.


observe that the client knows exactly which add and remove operations should be re.ected in the result of the checkout.


It is theoretically possible to develop a driver that is not based on explicit state machines such as in P, but is equally (or more) performant.

in practice, when we have tried to build such asynchronous drivers directly, we have run into myriad of synchronization issues and unacceptable degradation in reliability.


In this paper, it is assumed that any collected usage data represents a correct behaviour of the component.

to enhance the reliability of the usage data, there is a need to do thorough checking of the usage data before using it for the parameter analysis.


The results con.rm the impact of UML on reducing overall e.ort to perform code changes.

e.ort savings was not observed when the time required for updating the UML diagrams was taken into account.


For example, it is perhaps easiest and most effective for a user to identify the private segments in an image by marking an enclosed area using her  Figure 3: Overall approach of data partitioning .ngers or a stylus.

it may be easier to identify the lines containing sensitive information in a text document by searching for keywords and phrases provided by the user.


For example, theAPGANSAS algorithm clustersthegraph toA((BC)D) and generates the schedule as 40A3(5(2B3C)3D) which requires 141 data bu.ers.

the cluster of A((BC)D) is not feasible for dlcSAS.


In a .nite setting the corresponding .k woulddepend onthe particular values of dk(i).

in the asymptotic case, I L [1+K.Pl(j)dl(j)a] ' N(l,j) [ l '' 1+K.Pl' (j )dl' (j )a × = × by assuming a known law pk for the diagonal terms dk(i), l,j (l' ,j' )=(l,j) so that j nt 1 1 fk(t) L .


Scalar operators execute relatively quickly, so interpreting the .rst few iterations of the loop is feasible.

the cost of vector operations is dependent on the size of the vector.


Two of the common difficulties these libraries address are managing states an interface s status, which often controls its appearance and behavior [1,33] and expressing constraints relationships among interface components and underlying data models [21,26,30].

it is still difficult to integrate constraints or state models into imperative languages, in part because most development tools are designed for presenting, navigating, and debugging sequential code [22].


In recent years, signi.cant advances have been made in the area of automated tool support for refactoring [4, 12, 16, 17].

to our knowledge, we are the .rst to present semi-automatic refactoring support for making existing Java programs reentrant.


Considering a DS-CDMA based cellular network as an example, multiple users are allowed to transmit their information (digitized voice or data) signals simultaneously over the same frequency.

each user is assigned a specific spreading code which serves as the ID for that user.


Mobile payment-based solutions, such as MTN Money [3] deployed in several African countries, can somehow aid in tackling the problem of manual financial operations.

they do not address the issue of online social interactions, a problem that we believe on-line social networks can solve.


While ASDF maintainer, Gary King decided to integrate A-B-L into ASDF, which solved the .rst issue with A-B-L (loading it).

this didn t solve the second issue (con.guring it).


They have comparableorbetter accuracy.Figure7(a) showsthat for allofthe applications,the80thpercentile energy estimation errorunderFSMislessthan10%, andislessthan5% ifweincrease the timeintervalto1s(not shown).

figure 7(b) shows that LR with 1s intervals (LR/1s)performsfar worse thanFSM.The error at the80th percentile varies between 16% and 52%.


Identifying such bottlenecks is greatly facilitated by instrumenting code in ways that are rarely foreseen when the system was .rst designed.

adding such pro.ling (for example, tracking changes to a portion of global state) often requires extensive widespread (though locally small) changes to code.


The method start has to fork a call to solve, and thus also needs read permission to p.f in its precondition.

it does not return all of this permission to its caller; some is passed to the forked thread.


CTE-XL tool 2 , based on classi.cation tree method, allows users to generate pairwise and three-wise covering test sets, while handling constraints among input parameters.

constraints are handled in a passive way, by checking generated test con.gurations and possibly refuting inconsistent combinations.


3.1 Base language The abstract base-language representation IBaseLanguage provides information per language and is independent of the processing of concrete source .les.

the base language gives rise to fresh base-language processors via the method createNewProcessor.


In the example it is intuitively clear which ordering is desired.

given the occurrence of circular dependencies and/or negative dependencies (i.e.


In that model, nested transactions are closed; the parent transaction inherits all locks of a committing child transaction.

on con.ict a child transaction can be aborted without aborting the parent, reducing the overall cost of an abort.5 Other researchers in the database community extended this idea to support open nesting models that allow child transactions to release locks early.


For example, B has operations and Alloy has parametrized predicates to represent an action on the model.

sMT model uses a low-level language that does not possess mechanisms to allow the animation of the model.


With only normal-form rules, a parent node of such subtrees cannot see a difference between these trees (because it can access the trees only through non-terminals at the root node of the subtree, and these are the same in the two subtrees), so they really are equivalent.

a non-normal-form rule applicable at the parent could access nodes below the root node, and thus see differences between the subtrees, so the subtrees are not equivalent in this setting.


A request is divided and dispatched to the queues, and the entire request is ful.lled upon all the involved banks complete their parts.

its bene.ts would be largely limited by tra.c to hot data or garbage-collection activities.


e[v/x]: t ' holds if G fw v : t and G,x : t fw e : t ' .wehavetoworka bit harder to understand the consequences of transitions of types 7 and 8 for contextual equivalence at atom binding types, t bnd.We address this in the next section.


However, since concurrent relocation of objects seems to be hard to do in most currently shipping collectors, their young generation collectors are inherently stop-the-world, and are exposed to signi.cant pause time effects that arise from large transient behaviors or a signi.cant allocation rate of mid and long lived objects.

concurrent single generational collectors, even when they are able to avoid or delay the use of stop-the-world  Figure 1.


Our model of Mealy peers is similar to Communicating Finite State Machines de.ned in [12].

in our model messages are exchanged through a common medium and then stored in the queues of the peers, whereas in [12] each pair of communicating machines use isolated communication channels.


Consider the following situation in which several transactions concurrently update overlapping sets of objects: T1: T2: ... Tk: x:=1 x:=2 x:=k y:=1 y:=2 y:=k z:=1 z:=2 z:=k commit commit commit Rigorous scheduling requires that all but one of the transactions get blocked or aborted.

a user does not really care as long as the end result is consistent (i.e., reading x, y and z always gives x = y = z .{1,...,k}).


For instance, if a privilege of an attacker negatively depends on another privilege of the attacker, logical attack graph can represent that the .rst privilege is attainable by the attacker as second privilege cannot be attained.

it cannot give any reason as to why the second privilege cannot be attained.


Such studies are left to future work, when such multicores become available.

compute-intensive benchmarks will likely continue to bene.t from the lower scheduling overheads of work-stealing schedulers, for the next few generations of multicores, if not longer.


5.4 Code Cache Coherence One of the most effective optimizations that make dynamic translation a viable technique is the reuse of translated code through the maintenance of a code cache.

the reuse brings an important challenge: keeping the code cache coherent with respect to the original code.


Approaches in this class include GenVoca [2], mixin layers [28], delegation layers [25], and AHEAD [3] and will be referred to as featureoriented approaches in the reminder of this paper (FOAs for short).

a number of aspect-oriented approaches have been proposed that deal with the localization and modularization of crosscutting concerns [12, 30, 13, 4].


For example, we couldhave addedthe externalinteractors to the target architecture.

because external interactors represent components that are outside of the system, they will alwaysshowup asabsences.


In this approach, which is similar to our approach on the conceptual level, the re- engineer repeatedly chooses an adequate mapping rule for each schema artefact.

this stepwise process creates an object- oriented schema, therefore axioms are not discussed.


[40, 39] have also implemented loop parallelization in the context of JikesRVM.

rather than GPUs, their intended targetisJAMAICA [2],a multi-processor parallel architecture.


Next, the performance gap between the LSTAFF* and LSTAFF is smaller in the patterns of company B and C. This is because that the patterns of company B and C contain small random writes and frequent large sequential writes.

the patterns company A, Linux, and Symbian contain many random writes and infrequent large sequential writes.


Some other approaches like CGL MapReduce [18] also propose a solution to improve the performance of scienti.c data analysis applications developed in MapReduce.

their approach is fundamentally di.erent from our work.


Thus, simpler hardware in the form of scratchpad memories or partitioned caches is often employed.

distributing data across these simpler memories and then taking advantage of it in the compiler is not a simple task.


A later extension of this approach reduces the number of questions to the developer [9] by incorporating FLTL properties [15].

these techniques can synthesize overspeci.ed models and require signi.cant human input.


In each iteration, the underlying Theano runtime creates an array on the device memory and launches a GPU kernel to update the elements in the array with an incremental value.

there is a bug in Theano and the array is not released by Theano when the iteration .nishes, adding a memory leak delta of about 40MB.


Brown's Threads Package [3] is a system similar to ours with the same design merit.

this is a stand-alone class library rather than a component of a large system that can help stu-dents learn multithreaded, multiprocess, parallel and distributed programming.


For most of uni-processors like RISCs, compilers still managed to include architectural details.

the gap between the architecture complexity and the amount of information that a single tool can incorporate has grown wider: more complex architecture templates appear, like (clustered-) VLIW DSPs, ASIPs (Application-Sp eci.c Instruction set Processors) and eventually multicores which have multiple of those scalar processors on a single chip.


However, as an advantage the algorithm s training time improves.

rOS, replicating instances, can lead to over.tting and training takes longer.


Methods have been proposed to address this problem [4].

speculative pipelining can be used to dynamically redistribute work between threads to conduct adequate load balancing, as shown for ammp.


Having to deal with an additional meta-level adds a certain amount of complexity to the problem.

the feedback from our industry partner indicates that, in practice, the benefit of being able to deal with complexity at two levels outweighs the cost of the added complexity.


Such a concept should apply to code level testing too.

the tracing process for code will not be as simple as in Simulink.


In addition, this section also shows how temporal isolation is provided amongst components.

it is important to note that since nuclear power plants are safety critical systems and their monitoring and control systems have hard real-time requirements, we do not see this domain as a realistic target of the OSGi Framework.


The detector has 80M channels and 32bits per channel, so the collision rate translates into a roughly 10 PB/s information rate, which is reduced in realtime to 150Hz x 1MB = 150MB/s to tape via a mix of .ltering and zero-suppression.

the experiment took samples at a rate of 1000Hz during most of the 2012 data collection runs.


On the other hand, virtually all processors today need to run multimedia applications that offer easy to use parallelism.

to use this kind of parallelism ef.ciently, a special class of parallel functional units is employed.


Portability In theory, the parser and Ace editor are also highly portable across different platforms and mobile devices.

in practice, the Ace editor has many patches for different browsers and platforms, and experiments with our own prototype showed that it was not yet compatible with tablets.


There could also have been bias in the self-selection of participants.

we should not discount our overall conclusion that our approach is usually comparable to the type-checker s messages and is often better.


Since this leak is associated with a resize event, it may not occur in highfrequency.

the cumulative effect of a large number of small leaks may be fatal.


INTRODUCTION Stereotypes are used to clarify or extend the meaning of model elements.

the most intuitive notations are not always the best performing ones.


Because result is de.ned outside the ForLexer functor, the result type of a parser cannot depend on its lexer.

the ParseError it raises on detecting a syntax error is parameterized by the token stream in fact, it takes a list of token streams.


A player sniper location generally slows the pace of a level while lowering tension as the player is able to engage enemy NPCs without being exposed to enemy fire.

if the sniper location is not isolated from the rest of the level, the player will have to defend the access point as well, increasing tension.


2.4 Semantic Analysis for Actions The clear separation of concerns and a good coverage of the four orthogonal dimensions of actions is arguably desirable for complex actions, in particular for complex actions in emergency management.

the resulting expressiveness comes at a price, namely the need for a strong semantic analysis capable of rejecting incorrect and faulty programs.


Therefore, smaller coalitions that fall into the desired quality category can reach the end of the game.

the headers do not shrink steadily from round to round.


A purely reactive description of the response for each box would be: when the mouse pointer is within my bounds, react to it like this .

the 2.5dimensional structure of the display dictates that when Boxes overlap only the front-most Box containing the event location should react.


The compiler only infers appropriate type declarations from feed descriptions and compiles the feed syntax into our representations.

as one might expect, interfaces using higher-order abstract syntax and Mogensen-Scott encodings are one step more complex than those involving the more familiar maps and folds.


Scheduled Communication algorithms save energy in highly complex, production quality MPI programs, with no source code modi.cation.

they leave signi.cant potential energy savings untapped.


As a software user, you may stay tuned and Write Useful Bug Reports (Section 4.2.13) whenever you deal with errors.

to contribute by developing code or .xing bugs, you need to familiarize yourself also with the source code and with development issues.


LiveWide-AreaMigrationofVirtualMachines IncludingLocalPersistentState oberg ¨Robert Bradford, Evangelos Kotsovinos, Anja Feldmann, Harald Schi Deutsche Telekom Laboratories {.rstname.lastname}@telekom.de Abstract So far virtual machine (VM) migration has focused on transferring the run-time memory state of the VMs in local area networks (LAN).

for wide-area network (WAN) migration it is crucial to not just transfer the VMs image but also transfer its local persistent state (its .le system) and its on-going network connections.


The major bene.t of this technique is that threads that appear to be in the computation-oriented phases have higher execution priorities, satisfying the .rst condition.

by using time-based quantum to determine preemption, it becomes more challenging to achieve the second condition as the volume of allocated objects is a more precise metric to describe the heap working set than time.


The implementation of such a smart composition environment is quite challenging.

this requires little (if any) changes in the existing C++ library environments.


Internal nondeterminism enables multiple threads to run simultaneously, which is essential to harness the power of multicore chips.

internal nondeterminism in parallel programs could also result in nondeterministic outputs.


So far, security and e.ciency of cloud storage have been separately investigated as follows: On one hand, security notions such as Proof of Data Possession (PDP)and Proof of Retrievability (POR) have been introduced for detecting that the data stored in the cloud has been tampered with.

the notion of Proof of Ownership (POW) has also been proposed to alleviate the cloud server from storing multiple copies of the same data, which could substantially reduce the consumption of both network bandwidth and server storage space.


While having achieved remarkably good prediction performance, most of these approaches predict bugs at the level of source .les (or binaries, modules, Java packages).

since a .le can be arbitrarily large, a developer needs to invest a signi.cant amount of time to examine all methods of a .le in order to locate a particular bug.


They focused on reducing the communication costs.

in [J. H. Chen and Maizel 1998] their analytical formulas they didn t take into account the value of the startup latency and the processors were assumed to be permanently busy.


Many of these technologies are being introduced and evaluated by many leading educational innovators in their research and teaching.

in the enthusiasm to explore and exploit the potential of these emerging technologies, there is the possibility that critical questions of Governance may be unknown, forgotten or ignored.


Lock-free behaviour is important in languages with an unconstrained number of OS threads operating without co-operation from the scheduler.

in SMP-GHC, the number of OS threads is set to match the number of available CPUs, and scheduling between Haskell threads is under the control of our scheduler.


Recently, 16nm NAND .ash memory has been developed by Micron [9].

with the technology scaling and density improvement, the reliability of .ash memory deteriorates, which introduces the exponentially decreased endurance [7].


IKVM allows both .NET de velopers to use Java classes and Java developers to use .NET classes.

java developers that seek to link against .NET assemblies .rst have to create stub classes against which Java can compile against.


They .nd a single localizable data and computation partitioning, and the data is tiled along only one dimension.

we .nd a full-ranked computation and data mapping in a uni.ed manner, and data is thus tiled along multiple dimensions.


The location of new added cells does not change the behavior of this proposal.

it results in a higher number of collisions, 40% more collisions.


An obvious and viable solution is to create the C-E protocol as a union of all component instance protocols cproti, such that the set L(CEprot) of event traces speci.ed by the C-E protocol is a superset of the set of traces L(cproti) for each Ci.

if the components are separate entities in the architecture, then they are typically used in di.erent ways speci.cally, their component instance protocols di.er to a great degree.


For Metis, the pure RCU design achieves near-perfect 75× speedup at 80 cores and outperforms read/write locking by 3.4×.

read/write locking s performance degrades with more cores because of both lock contention and cache contention for the mmap sem.


Its repetition vector is also AB2pC2p and it is clearly live with the schedule A(BC )2p .


These are based on deductive veri.cation [18], code generation [16], model extrac tion [4], re.nement type systems [20], or static information .ow analysis [24].

these techniques focus on source program veri.cation and do not explicitly address executable code, nor side-channel attacks.


Contextual information extracted from the user s environment can be used to inform adaptation strategies, which enables an app to optimize its behavior and functionality to better fit a user s changing situation and requirements.

context modeling and management techniques presuppose significant domain expertise in the areas of mobile, distributed and ubiquitous computing [1, 2].


Consequently, we have three distinct features: X with four repetitions in the family, with one repetition (used by one product only), and also with one repetition.

if for product D we have to develop another implementation for feature X, , then we will have four distinct features in the family.


5.2.4 First polymorphism task Only a portion of method calls in JAVA involve dynamic dispatching, and a much smaller portion of these involve dynamic targets whose documentation adds to or con.icts with that of the overridden static target.

we suspect that when these situations do occur, they present a particularly dif.cult challenge to developers, who are only exposed to the documentation for the static type.


5.1 Design Principle Violation Detection One of the most well-known and important principle in quality analysis is the fact that code should always exhibit low coupling and high cohesion.

this fundamental principle is very di.cult to verify because .nding threshold values and trade-o.s between coupling and cohesion is very context-dependent.


The problem of unsoundness of the conjunction rule in Hoare logic was already shown by John Reynolds in the context of concurrent Separation Logic [38].

the proposed solution was tied to the particular logic (enforcing the resources to be precise).


For example, suppose tenant t4 gives 8 as the importance of the requirement r3 , which means e34 =8.

when analyzing tenants SLA, the development team finds that it does not comply with the needed QoS of this requirement, which means sij = 0.


BCs can still be moved out of the loop even if they are executed conditionally.

this is more likely to cause guarded regions to roll back.


Thus there is no need to test at runtime for dangerous references that refer to an object in a region closer to the top of the stack.

the system is not safe for space complexity.


Pointers to those objects are sent to Java as ints, so that the programmer can pass them back to the JNI library to manipulate the window components.

since the ints are just ordinary integers as far as Java is concerned, the programmer could inadvertently pass bogus pointer values back to C, thereby potentially causing memory corruption.


The trivial model performs surprisingly well when evaluated using AUC.

when an e.ort-sensitive performance measure is used, it becomes apparent that the trivial model is in fact the worst.


This means mapping information between file and sector can be obtained at the file system level.

if requested data are cached in memory, the access cannot be captured at the file system level because the request is not sent to the file system.


Xsemantics does not aim at providing mechanisms for formal proofs for the language and the type system; for instance, it does not produce, like other frameworks do (see, e.g., [29]), versions of the type system for proof assistants.

using Xsemantics can still help when writing the meta-theory of the language.


Examples include connect and accept system calls, and read and write system calls on streams.

when two processes monitor the same .le using the select system call, a .le state change will notify both processes equally.


For enabling embedded DSLs, Scala relies on a variety of ingeniously conspiring but separate mechanisms: some implicit syntactic elements, block syntax, lazy .elds, implicits, to name some.

star features uniform syntactic extensibility through its macro system.


typical sizes for current desktop machines.

there is a signi.cant drop in performance thereafter and therefore poor scalability for now.


Also, a system becomes easier to update: on the one hand, we can replace a component with another version without having to change any other component or the coordination scheme in the system.

we can replace the coordination scheme with another one without changing the components of the system.


First and Last Message: Users are not able to go from the second to the .rst message by pressing the Up key, or to go from the second to last to the last message by pressing the Down key.

users can use the Page Up and Page Down keys to accomplish these tasks.


The reasoning process may then decide that several nodes in a room have to be transformed into dedicated aggregation nodes to which sensor data is forwarded to.

depending on the state of the network, the corresponding con.guration for this policy may have to change in time.


This can be done by using UML diagrams: use case diagrams to provide a static process view, by organizing processes hierarchically as use cases and showing which stakeholders are entitled to participate in their realization; activity diagrams to deal with dynamic aspects of the system, rendering processes as actions which transform entities and their state; ob ject diagrams focus on describing the design space assumption and constraints which in.uence the process.

uMLbased methodologies are not .exible enough to capture and model alternatives.


Our approach makes extensive use of both early and late aspects throughout the software development lifecycle, with aspect-based characterizations of components used in requirements engineering, software architecture and component design, component implementation and at run-time to support dynamic component discovery, integration, and deployed component testing [9], [11], [13].

as AOCE adds extra complexity to component requirements, designs and implementations, using AOCE without adequate tool support is very difficult [11].


The original paper generates w using a pseudo-random number generator (PRNG) with a secret key K as the seed.

k has no other use, and it is su.cient for the attacker to recover w. Our attack makes no assumptions about the PRNG, and it will work even if w is a truly random image.


Most service times are small, less than 54 milliseconds.

two interactions, the Best Seller and Administrative Control servlets, have service times of over one and two seconds, respectively, in the no-load case.


The basic, classical GA [9] has been successfully applied to this problem area.

falkenauer [5] pointed out the limited suitability of the basic GA for grouping problems and proposes a heavily adapted GA, GGA, to solve the problem of clustering data into groups.


RELATED WORK The idea of service partitioning has been advocated as a mechanism for distributing a software application across available computing resources [10, 14, 17].

to the best of our knowledge no existing approach addresses all the requirements of service partitioning in a pervasive environment identi.ed in Section 2.2.


Greedy constraint solving The greedy constraint solver handles the type constraints one at a time, and has two advantages: it is implemented in a straightforward way and has a good performance.

this solver is highly sensitive to the order in which the type constraints are considered, and is biased just like Hugs and GHC.


When profile data is collected and hot traces are identified and codified as inlining rules, we do not merge partial matches.

when the inline oracle is determining which inlining rules are applicable to a candidate call site in a particular compi- lation context it allows partial matches.


As we showed, one can assure correctness when generating dependent advice.

when a programmer writes dependent advice by hand, it is her responsibility to assure correctness.


We observed in this empirical study that using one or two of the mentioned four reference process elements has no significant impact on improving predictability.

combining 3 or 4 of these elements in a project reduces delays significantly!


When a query aimed for some speci.c .les are raised by the .le requester, the index node will respond with a list of related indices for the .le requester to select.

due to the lack of central authorities in systems, some peers may perform some malicious behaviors, e.g., a .le provider may insert into the system a lot of polluted .les, and the index node may fabricate the maintained indices.


Similar to us, their framework uses updates as a start point to .x inconsistency.

they still require developers to write .xing actions for each type of updates.


The main drawback of these tools is that their levels of granularity are too coarse, because they operate at the file level.

scattered feature information tends to be interleaved within files as well, so these tools need to extend their reach.


Many of the resulting API usage mappings involve a single API class/method (220 out of 435 mappings) and a single variable in Java (357 out of 435) 1.

there are many other resulting mappings involving multiple API classes/methods (215 out of 435) and multiple variables (78 out of 435).


Current bandwidth capacities might not be big enough to realize our scalable approach.

the overhead is constant only depending on k. It does not depend on the number of nodes, so it is inherently scalable in contrast to the broadcast-based approach.


From this information the path executions can be approximately estimated.

whole program pro.ling usually gives very exact information about paths execution but with a bigger execution overhead cost.


On one hand, the metalanguage is expressive enough to implement an unparser, and, hence, can instantiate any semantically correct program in the object language.

the metalanguage is restricted enough to enforce the model-view separation in terms of Parr [21].


A lot of existing algorithms takes only either computation or communication imbalances into consideration but not both.

our algorithm functions best when both imbalances are present which is the case in most simulations.


To minimize these overheads, we designed a P2P message passing mechanism among mappers along with data compression to reduce communication overheads.

pursuing prediction accuracy and efficiency in targeting imbalances without also tracking overheads can be problematic.


[4], used a compiler based static analysis approach to estimate the execution time.

it emphasized only on the execution time of the program rather than the entire resource model.


Their work is similar to ours in that they propose using objects to construct and output SQL strings.

they do not propose any sort of compile time checking of the validity of the generated SQL statements.


This perception of compositionality allow us to justify the existence of managers.

we still need some techniques to reason about processes in the presence of managers.


Evolutionary techniques bene.t from smooth .tness landscapes, but use biologically inspired techniques to jump across poorly performing regions of the space.

constraint solvers typically do not incorporate .tness functions, but are a proven technology for solution spaces where most choices are maximally bad (i.e.


Figure 3 suggests that mature object compaction in the free-list will be of little use for these programs.

figure 2 reveals the two exceptions to this rule: 209 db and pseudojbb.


An optimization for short-lived capability allocations is to integrate release of an old capability (unmap) and acquisition of a new one (map) into one operation by simply overmapping an already allocated capability index.

if used improperly, this may lead to mysterious program behavior.


Also, the written feedback prepares for the kind of and tone of feedback the author is going to receive when submitting the paper to a scienti.c conference or journal.

not directly telling the author your opinion increases your communication overhead and you might end up beating around the bush.


The program above looks simple because Kerninst provides a mechanism for .nding the address of the entry point of a function.

if we want to print a log message in the middle of that function, we must manually calculate the address where the hook code is inserted and then we must pass that address to insertSnippet() instead of entries[0].


2.8.2 Compatibility Issues int x = ++a; Ideally in Kava, all variables would be bound references by de- fault.

this is incompatible with Java, in which primi- tives always behave like bound references and user-defined classes are always optional references.


J& and gbeta support multiple inheritance, which is something that GPT does not allow.

for code composition, we can attain some of the bene.ts of multiple inheritance by merging template classes.


We believe that in SPM it is important to describe the program and the theory behind it, the model.

the focus is not to represent the model itself, such as a formula or an 455 algorithm, but to describe it with adequate semantic to facilitate the decision of its adequacy to the problem in hands.


The problem of determining whether two Fµ types are uni.able may be turned, in a very simple manner, into a nominal uni.cation problem [21], provided nominal uni.cation is extended with support for recursive terms, which appears straightforward.

neither we nor Urban [personal communication] are currently able to formulate a nominal uni.cation algorithm whose time complexity is less than O(n2).


0 [(0.0,0.0)] ) The standard OCaml compiler reports a type error in the shaded expression on line 10.

the actual error cause lies in the misuse of the print string function on line 7, as reported by the authors of [42].


These implementations have to provide a translator from the guest languages high-level semantics to the low-level semantics of LLVM IR.

our approach requires only an AST interpreter; our system can be thought of as a High-Level Virtual Machine (HLVM).


To overcome this lack, the OMG released fUML 1.0 (Semantics of a Foundational Subset for Executable UML Models) [21], a new standard that precisely de.nes the execution semantics for a subset of UML 2.3 in a form of an Execution Model implemented in a virtual machine.

in order to ensure the success of the development [14], models need to be veri.ed at early stages of the development lifecycle.


Such a setup also ties PVFS with other .le systems and limits its portability.

providing CRC checks within PVFS allows taking advantage of user space caching on servers.


In Pythia the remote community is chosen randomly.

this selection can be done more ef.ciently and purposefully if users can advertise (see Section 5) their topics of interests anonymously and a DHT mechanism provides the correlations between communities and topics so that questions can be directed to appropriate communities with potential answerers in that area.


Methodology 6.1 Program-speci.c, true prediction Our purpose is to explore the extent to which micro-patterns can provide program-speci.c prediction to guide pretenuring.

it is important that such program-speci.c prediction nevertheless be true prediction rather than selfprediction [4], that is, the prediction should not be derived simply from a past execution of the same program.


Traditionally, .le systems have been designed at the level of the VFS interface, not breaking into the libraries themselves.

it appears that .le systems now need to take a more vertical approach and incorporate some of the functionality of modern libraries.


For these reasons, speci.c methodologies for WIS development and, also, tools to support them have appeared.

the most of these tools usually do not include the activities for the analysis of the consistency of the models built or, if they exist, they are not very powerful.


Thus the lack of a rigid organizational structure may in fact be a boon to OSS projects.

the absence of any structure at all may be just as harmful.


Therefore, the technique in Section 2.1 can be used to generate test packets in this process.

testing correctness is only a small part of the IDS evaluation.


Had these models been used within our sample of 1,652 warnings, triaging engineers would have examined hundreds of fewer spurious and non-actionable warnings not an insigni.cant savings when the cost of triaging is estimated at eight minutes per warning (as discussed in Section 2.1).

this comes at a cost due to the incorrect predictions made by the models.


Antfarm does not ef.ciently allocate bandwidth from multiple origin servers or from in-networking cache servers, which belong to multiple, overlapping swarms.

v-Formation accounts for bandwidth from all hosts based on real-time measurements using the CPM.


Any other computations initiated in p will be terminated, along with the delay and the default computation.

if the delay turns out to conclude sooner than the Orc expression, and if def then produces a value .rst, it will be the sole value returned.


These tools also aim at lowering the entry barrier for starting to develop JNI-enabled Java software.

all these tools increase also the staticfootprint, since there is new native code introduced.


The return results object is copied back to the caller, which is free to modify its state.

if the server has aliased this object prior to returning it to the caller, the client-site modi.cation will not be re.ected in the remote component s state.


So it seems that proofs in their universe do not need the sort of infrastructure we de.ne in this paper.

the style of programming is very different and a Generic Haskell programmer would not recognize the de.nition of map; moreover, the de.nition of the functor laws isnotasdirect(forexample,aspecial composition operatorneeds tobede.nedfor composition of morphisms over environments).


One of these issues is caused by JAVASSIST, the class library used for the actual byte code manipulation.

we are in contact with its developer in order to .x that bug4.


SRT, on average, degrades performance over running just the single thread (without any redundant copies) by 32%.

sRT techniques improve performance over 106 100 ~, ~ '~'; ............  i ~, ,~i ' ~:<.


This heap layout results in large regions without guard pages, allowing single over.ows to overwrite large numbers of heap chunks.

openBSD s allocator uses a sparse page layout, where small objects are allocated within pages spread sparsely across the address space.


One could say that the latter makes the .rst redundant since sending the response is of course an indirect acknowledgement for the initial request.

when the computation time on the server for producing the response is considerably longer than the transmission time for a signal (since it for example could include further communication with other components), the extra acknowledgement would allow the client to detect communication problems earlier.


One promising approach to make interaction with mobile devices more efficient and pleasant is utilizing UI devices in the user s environment, such as, public displays.

it is not clear to what extent the user is able to benefit from using external UI devices.


NTFD does not change the network s behaviour because there is no intrusion to the network operations.

hBFD has the advantage of maintaining strong completeness property.


A naive algorithm to compute equation (3)has complexity O(d· N· S3).

since the marginal probability indeed comes from only one dimension along the scanningdirection(e.g., aline),the complexity canbe reduced to O(d· N· S1.5) after algorithm optimization.


In contrast, when a transformed function is called from an unsafe (third-party) context, unless the call is in tail position, the continuation frame does not contain an unsafety mark, so the safety mark does not override any marks.

call/cc will fail because when it captures the SAFE?marks with c-c-m, it will extract a list like (list ... false true ...) where the frames between false and true were the third-party context.


They are warned that it is unlikely that they will be helped during the trial.

they are contributing to the future of science and medicine.


S3D, which uses relatively smaller amounts of memory per core, .ts well with architectural assumption.

in cases where the assumption does not hold, i.e., exascale systems have larger memory sizes per core, we can still estimate the overall overhead due to fault tolerance.


Jadex and Jade provide Java classes for implementing FIPA interaction protocols, so the programmer can t use other specialized programming languages (like AgentSpeak) with more facilities to model and describe agents.

none of the analyzed platforms allow to dynamically modify the steps sequence in the interaction protocol in order to create more open and .exible conversations.


For example, if we know that input I is 0 then we expect the output O to be 0 after the rising edge of CLK.

considering the execution trace in Figure 5 and assuming solely p2 to behave correctly yields to contradiction, since we expect O to be 0 instead of 1 .


[2008] and Ré [2009], there are no works focusing speci.cally on stubs and drivers implementation for AO software.

there are some interesting related papers such as the work of Binder [1999] that analyses several integration strategies and design patterns to test object-oriented software, and the work of Pasternak et al.


Their language Lk involves predicates that contain numeric constants no larger in absolute value than k from the constants that already occur in the program.

the choice of the language used in our implementation places restrictions on the size of the boolean formulas, which is motivated by the fact that most programs are usually correct for simple reasons that can be expressed using some small representation.


Moreover, combined approach appears to improve the ranking quality as compared to when only one feature was used.

again this was not the case when we assessed the quality of the 2nd level relative rankings (ref.


In two of the three open source projects they looked at, commenting was relatively constant over time.

there was variability in that one project increased the ratio of commented to non-commented lines of code over time.


To avoid copying data in or out of small data sections at migration time, we add support for small data sections to the GCC ARM back-end.

we do not change the compiler to generate ARM code that can take advantage of the small data section by generating code to access data in these sections with fewer instructions so the performance of ARM code is not improved, but is not degraded either.


Background execution of test cases allows the developer to al- Figure 5: Architecture of Cdd implementation ways see the latest state of the test cases.

in addition to this,thedevelopermaywantto more clearly understandwhyaparticulartest casefails.Forthis caseCddallowshimtoexecuteatest caseintheregulardebugger.


Liivi 2, Tartu, Estoniamartti.vasar@ut.ee satish.srirama@ut.ee marlon.dumas@ut.ee ABSTRACT By allowing resources to be acquired on-demand and in variable amounts, cloud computing provides an appealing environment for deploying pilot projects and for performance testing of Web applications and services.

setting up cloud environments for performance testing still requires a signi.cant amount of manual e.ort.


Today, objectoriented databases still play an insignificant role in industrial software development.

databases using nonrelational data structures, socalled NoSQL databases, are getting popular for high performance and large volume applications now.


RE L AT E D WO R K In the past, debugging techniques based on formal methods have been proposed in the domain of logic circuit design [16] or the design modelling based on declarative speci.cations such as Alloy [17] and KodKod [18].

these approaches address languages and problems different from UML/OCL and, thus, do not consider the two-staged approach proposed in this work.


it should be noted that these three studies were conducted at di.erent times, and with di.erent selection criteria for the participants.


During October 2006, search engines comprised of approximately 43% of the available services during a WSCE crawl.

the growth rate for search engines with respect to indexing services has grown significantly in which 72% of the services during a recent WSCE crawl are captured through search engines (Tables 1 and 2).


Architecture analysis methods were not used at all.

component and integration testing could be improved only a little in the real-time software domain contrary to telecommunications, data processing and management, and hardware-related software domains in which the domains component and integration testing was ranked to be at the level 0 or 1 (scale 0...5).


CONCLUSIONS AND FUTURE RESEARCH DIRECTIONS In this study, the proposed negotiation architecture has a solid foundation grounded on the BDI theory, and can be easily implemented using existing software agent technology.

the proposed negotiation decision-making model can support dynamic selection of the negotiation strategies during the negotiation process.


Such ecosystem formed by service providers, mashup authors, and users as visualized in Figure 1 need not be controlled by a central authority.

even though mashup authors and service providers may have explicit service level agreements (SLA), it is common that mashups are developed without such contracts, and the ecosystem is formed implicitly.


Observing and registering the results of the test deployment may itself disturb the results, hiding interesting system properties.

building a simulation model frees testing from the availability of the target platform for deployment.


In the examples in this paper all inputs can be actively controlled externally.

there are some test cases which require internal control of inputs.


Assessing the Impact of Refactoring Activities on the JHotDraw Project Ishwor Thapa, Harvey Siy Department of Computer Science University of Nebraska at Omaha 6001 Dodge Street, Omaha, Nebraska, USA {ithapa,hsiy}@unomaha.edu  ABSTRACT Refactoring is a well-known technique for improving the maintainability of software products.

it is not easy to justify the time and e.ort needed to refactor code as thebene.ts are di.cult to quantify, especially theperception of improved maintainability.


t-kernel provides a safe execution environment that allows the system to recover from problems such as deadlock or livelock.

tkernel is designed for reliability rather than debugging, and only ensures that the system can always execute.


Our techniques [27] generate unit tests for aspects by feeding the complied aspect classes to existing Java test-generation tools such as Parasoft Jtest [19], JCrasher [7], Rostra [24], and Symstra [25], which can generate tests based on Java bytecode.

these Unit tests Integration tests Test-input Aspectual behavior JamlUnit [14], AJTE [29] Aspectra [26] generation Aspectual composition AJTE [29], APTE [2] Test oracles Aspectual branch cov [26], data.ow cov [30] data cov [28], Pipa [31], muJava [15] branch cov [26], data.ow cov [30] data cov [28], Pipa [31], muJava [15] Aspectual composition interaction cov [26] data.ow cov [30] pointcut mutation testing [3] Table 1: Classi.cation of automated testing techniques for aspect-oriented programs Java test generation tools based on bytecode are not able to generate meaningful tests for advice methods whose argument types include JoinPoint or AroundClosure.


To the best of our knowledge, there is no prior work specifically on merging models that describe the observable behaviour of a system.

merging operational speci.cations in which system states are explicitly described is frequently done (e.g.


scheduling the loads #3 and #4 for 2-cycle latency slows down the program significantly.


Furthermore, they can support unsigned immediate values from 0 to 7.

instructions that have 2 operands (like move) have 5-bit operands.


Their approach might be reasonable in the very early stages of gameplay modeling.


A paradigm emerging by meeting a need is much more convincing as a bona fide contribution to the field than a paradigm searching for a need to be met.

the latter was the situation with this assignment.


Testing of this new regridder showed good scaling up to 98K cores at which point there are only one or two patches with 4096 cells per core; at this point scalability beginsto breakdown.

thekeyproblemwasthatwe were notabletorunalargerproblemwith morepatchesper coreasthere was insuf.cient memory to accommodate the larger run.


For the time being, only quasi-synchronous clocks are handled.

the principle can be easily extended to clocks with more complex relationships.


For instance, the value di.erence of a traditional slice necessarily includes the predicate on which it is control dependent.

if the predicate is aligned in both passing and failing runs, it itself is not a trace di.erence, and does not need to be included in the dual slice.


We know that these issues are important for the successful uptake of research into practice and that there are interrelationships among organizational systems, structures, processes, technologies, settings, and cultures.

the nature of these relationships is poorly understood.


However, in these works dynamic histories of different executions, corresponding to two different inputs, of a single version of a program are compared.

our work considers matching of dynamic histories of two program versions on the same input.


This sort of policy is possible in scenarios in which each server is largely stateless, as is the case with the .rst two tiers in 3-tier Web services.

cluster applications might be heterogeneous and the previous assumption does not hold in general case.


However, object-based approaches cannot always enforce complete spatial safety because of sub-object over.ows.

pointer-based approaches typically change the pointer representation and memory layout causing source code compatibility problems.


Compared with our approach, the major advantage of CCured is that it guarantees the absence of dangling pointer references and also performs exact bounds checks on all memory references.

a key contribution of our work has been to enable sound analysis while still retaining explicit memory management.


Indeed, the increase of the neighborhood size may improve the quality of the obtained solutions.

its exploitation for solving real-world problems is possible only by using a great computing power.


Because of this, their results are independent of the garbage collector used, hence they are not appropriate for analysing different aspects of the behaviour of the collector itself.

the GCspy framework was designed for exactly this purpose.


9) that de.nes which features are added to C and which features are removed from C during adaptation.

as we explain below, it is usually too restrictive to directly de.ne con.guration changes in an adaptation rule.


An analysis similar to the one done with MultiVeStA, including the reuse of simulations, can be performed using DEUS alone, by logging the required measures during simulations.

no CI evaluation facilities are provided, thus it would be necessary to launch the simulations, to compute the CIs, and to launch new simulations if necessary.


For example, the append operator @ on lists, which is speci.ed by the equations Nil @ ys = ys (Cons x xs) @ ys = Cons x (xs @ ys) will over.ow if the longest representable nonempty list is appended to itself.

selectors such as hd (head) and tl (tail), which return the .rst and second argument of a Cons, cannot over.ow.


Then, x.i = 0 since both the cooperative and adversary values are removed.

using Lemma 2 while treating i as an adversary, ensures xj (t) - xi(t) >E .j .Vc {i} and t = 0.


Test scenarios based on UML statechart models can be visualized as instances of paths in the model.

for test generation purposes, what is required is event generation capability that can capture different variations or characteristics of events.


The implementation shows that concurrent dynamic memory allocations in massively parallel architectures do not need to be slow.

the assumption of the allocator do not allow it to be an all-round solution.


The chosen codes detect and correct multi-bit faults.

this scheme allocates a large area to store a multi-bit ECC for every cache word.


GPUs have the potential to support large-scale parallel applications on very inexpensive hardware.

the programming model for GPUs is quite complicated, limiting its accessibility to only very sophisticated programmers.


Indeed, the well-known Unified Modeling Language (UML) has for years had a specification that is far from precise.

precise models are quite common in other engineering disciplines, and there has been a minority even in software engineering that have created models that are precise enough to be, themselves, executable.


For each of the 32 grid points to be updated, if the update location lies within the thread s exclusively owned grid, the increment may be performed without any synchronization mechanism.

if the grid point lies outside the thread s exclusively owned grid, the thread will write to the shared grid using a synchronization mechanism to obtain exclusive access.


In this case, the agent discovers that her menu contains too much fat and not enough calcium, so it suggests replacing al kharoof bel roaz with sayyadieh (fish with rice) and suggests nooranoush (pomegranates and yogurt) for dessert.

fAQIH also warns her not to buy yogurt of a specific brand, because it seems to be causing an outbreak of diarrhea in a close-by locality.


Perhaps surprisingly, some implementations of this instance require only Haskell 98.

if we need to have structurally-dependent variables, then we also require multiple-parameter type classes.


In summary, our model introduces some hidden dependencies and decreases visibility.

we believe these are outweighed by the increase in speci.cation consistency of visual encoding and interaction, and the decrease in viscosity by supporting abstraction mechanisms.


These studies applied mainly quantitative analysis.

qualitative inquiry provides an interesting way of building knowledge on how human subjects reason about software quality attributes.


Furthermore, existing research tests a migration at only one or at particular times in the whole run of a workload on a VM.

when a VM server runs in a real scenario, it could be migrated at any moment and most likely will produces di.erent results.