collect_first_results(K, ThreadCount, Hub, MoreXs): K>0, ThreadCount>0, ask_interactor(Hub, Answer), count_thread_answer(Answer, ThreadCount, ThreadsLeft, Xs, MoreXs), ( ThreadCount=:=ThreadsLeft->K1 is K-1 ;K1 is K ), collect_first_results(K1, ThreadsLeft, Hub, Xs).

searching for at most one solution is possible: multi_first(XGs,X):-multi_first(1,XGs,[X]).


(4)  <xs:element name="Location" type="xs:anyURI"/>    Consequently, the subscriber must implement the STAIVE interface as well, if call-backs are required.

the subscribed FDX can process the call-back easily by sending back the invoke context handed over before.


The generated con.guration .le is correct.

the translation of high level representation (AADL models) into C con.guration code preserves speci.ed requirements.


For the application case, the WakeLock anomaly occurs when the running application is stopped.

the application that has generated the WakeLock anomaly is not currently used by the user.


This paper shows that the organization of the code cache, which stores dynamically generated code, can have a significant impact on the overall system performance.

we show that dividing the code cache into distinct segments each of which contains a particular type of code can improve overall execution time by up to 7%.


128 FIA repeatedly executes while there are un.lled form items remaining, the processing phase (Process) is e.ectively parameterized by the form-level grammar .le.

the form-level grammar .le not only enables slot .lling, it also implicitly directs the staging of interactions for mixedinitiative.


We intend to continue the development and integration of advanced compilation techniques.

we want to address inter-procedural and inter-modular boxing and unboxing, as well as to explore the tradeo.s of doing additional boxing/unboxing steps, which has an extra overhead but which in general may bene.t other parts of the code, and generating automatically hints for the garbage collector.


5.2.3 Scope Increases and Decreases Increases or decreases in the scope of a model de.nition rule may change the abstract model.

if the change in scope of a model de.nition rule causes an ob ject (or tuple) to be added to or removed from a set (or relation), the resulting change in the model may falsify model constraints that depend on the set (or relation) or cause additional changes in the scopes of other model de.nition rules.


Indeed we have implemented the protocol in Erlang, with very encouraging results so far.

we have been able to work with much larger systems than those reported in [1], i.e., using 3000 agents compared to 40, and with much better performance.


By removing ASIDs, we needed some other method to prevent dangling references within frame caps.

we needed to store a back-pointer from a virtual address mapping to the frame cap used for the mapping.


Following the philosophy of the Ravenscar profile, we propose a high integrity profile for real-time Java (called Ravenscar-Java) that offers a more reliable and predictable programming environment.

our profile eliminates features with high overheads and complex semantics, so that programs become more analysable and ultimately, more dependable.


Reliability: This work is trustable guarded boundary conditions that the study presented: management of model transformation assets, considering communalities and variabilities in information system development with variant Java J2EE architectures.

this work is invalid in software development scenarios whose target architecture not varies.


Morever, in the case of hosts within reach, the interval between update shipment is based on the evaluation of the accuracy of others prediction.

hosts send updates only when the predictions others will make about their state become inaccurate.


While this approach exemplifies the automated use of statistical testing as part of the decision support, it does not elaborate further on this topic.

groeda does not mention how the single results of the repeated tests are aggregated and how the result is presented.


Especially, set performs differently on the two microarchitectures.

for test and reference inputs, set outperforms vector on Core2 microarchitecture while the data structure replacement to set does not achieve signi.cant performance improvement on Atom microarchitecture.


This interme- diate representation is used as the basis for slicing by our implementations of the algorithms.

when slicing is performed, we compute the slices in terms of a set of statements from this IR.


When theproperty being checked requires morepredicates,theveri.cation time increases rapidly.

.xing the bug mentioned above results in a signi.cant increase in the number of predicates required to verify a claim using the sequential model: Thenumberofpredicatesincreasesby afactor of10.


Constraint graph The core constraint language has a natural graph representation that enables analyses of the system of constraints.

the satis.ability of the constraints can be tested via context-freelanguage reachability in the graph.


Conceptual Architecture As introduced above, flexible modeling tools blend the advantages of office and modeling tools, thereby more effectively supporting pre-requirements analysts work.

they provide the free-form, relativelyunconstrained user experience of office tools blended with the support for structure provided by modeling tools, which facilitates multiple views, consistency management and domain-specific support.


Managing jobs with an interpreted language for dynamic adaptation * Anolan Milanés Pontifícia Universidade Católica do Rio de Janeiro Computer Science Department  anolan@inf.puc-rio.br Noemi Rodriguez Pontifícia Universidade Católica do Rio de Janeiro Computer Science Department  noemi@inf.puc-rio.br Bruno Schulze National Laboratory for Scienti.c Computing Computer Science Dep, Brazil  schulze@lncc.br ABSTRACT In this paper we explore the advantages of using interpreted languages for building submitting engines for the grid.

we discuss an example engine, developed using ALua, for submitting jobs in a cluster, which can be extended to a grid environment.


However, in order for this to happen, a mechanism must be included to combine proofs from these monitors to form a proof of rest of path quality.

the monitors must ultimately be combined to form contractible rest of path monitors.


Our architecture avoids any assumption of a trusted certi.cation authority, eliminating global key management as a deployment obstacle.

each site is free to act as its own authority to certify keys and to grant or validate claims on its local resources.


Spoon allows for the definition of program processors and annotation processors that use Compile-Time reflection, which is achieved with an extension of Sun s APT.

spoon provides an AOP extension under the form of a set of annotation processors.


The next workgroup investigation will focus on the hidden information.

the lessons learned that were never documented, open problems, confounding variables, results that were never replicated, results that are too general, the impact of real game development work and all the elements that go with it, etc.


The result of this combination of ideas is a language that allows a very natural integration of programming with session-based channels and with non-uniform objects.

the implementation of a session can be modularized by dividing it into separate methods that can be called in turn.


Software striping delivers both high aggregate data access throughput and scalability with regard to stripe width in a LAN environment.

with asymmetric striping, a client can combine its network data transfer with local disk I/O.


Di.erent from related works, in this paper, we study how content processing and distribution are jointly performed by the cloud.

we design deployment strategies for social applications by taking the characteristics in social media into account, based on measurement studies of realworld online social networks.


Cases 1 and 3 show that the developers had to adopt a consumer perspective to make their systems reusable.

one of the boundaries reuse projects must cross is from their vision of how to produce the product to an understanding of how their customers consume it.


Figure 12 points to a reverse relation between sX t and the related failure ratio.

smaller the value of sX t is, higher the ratio of related to total failures is.


Unfortunately, current programming techniques support only a manual determination of the PTG.

pro grammers must decide which parts of an application are best executed in parallel and what PTG yields good performance.


By Theorem 2 , we establish that Pr[4, 030 =fbI = 5, 970] =76% when fI =5, 000.

the probability that the error (when fI =5, 000) is within 20% is about 0.76.


Code duplication, which might arise as a result of carelessly expanding de.nitions, is easily avoided by caching the result of function applications.

there are some obvious limitations to our approach which we hopeto addressin futurework.anEDSLwithhigherorder functions would still retain an interpreter in the residual program, because higher-order functions accept functions as dynamic arguments, violating our Rule 4.


In this case, the right rule, whose matching larger, is selected.

the matching is with respect to the types of figures involved and their connectivity.


2P where P is a set of all users and W is a .nite set of all locations.

the function acl takes a user identity X and a location name l as inputs and outputs a set of users who are authorized to learn that Bob is at location l. the LSS releases Bob s location movement (lk,tk)to principal X only if X belongs to set acl (Bob,lk), and thus user X receives a subset of events L'(X) .


Among the four libraries, Apache and GSL are open-source scienti.c libraries, whereas JDK and MATLAB are commercial scienti.c libraries.

the source code of the latter two libraries is not available.


To see why this is so, note that sequential consistency does not require the actual execution order of operations to be consistent with any particular se-quential order.

operations of the same proces- sor may be performed in an order that differs from program order as long as both orders give the same result.


An edge corresponds to a part of a changeable computation that starts by reading an input modi.able, and ends by writing its output modi.able.

whenever a changeable reads a modi.able, an edge containing the continuing changeable is inserted in the dependency graph.


Discussion of .re .ghting scenario This scenario involves spontaneous networking, but relies on a reasonable level of connectivity between participants to maintain up-to-date information.

.re .ghters and sensors that are out of range of nodes in the other networks will hinder the application s operation.


The transformations were recorded by the library s revisioning system.

features in this study represent selectable development steps.


While suchfeatures are notavailablefor allkinds of image types and recognition tasks, several promising techniques have emerged in recent years.

when one is interested in searching for images of the same object or scene, a good representation is obtained using the Scale-Invariant Feature Transform (SIFT) [16], which generates 128 dimensional vectors by essentially computing local orientationhistograms.


Yet this design is being rejected for reasons that industry developers would view as purely academic.

the common case is being sacri.ced for the corner case.


While shared memory implementations rely on artificial barriers to implement a given algorithm from this group of dwarfs, which limits the parallelism and the performance, dataflow implementations support a straightforward implementation by directly mapping dependencies between algorithm operations into a task-based dataflow execution.

for these four dwarfs dataflow implementations provide on average up to 29.25% better speedup than the shared memory versions.


For example, if the array length of list in Figure 1 is .xed at 5, the search vector would be .

the .rst .ve values of the vector correspond to the .ve values of the list array, followed by the value of the size variable.


We extend LTS by incorporating XPath Rewriting Graphs (XRGs) [14], which captures the relationships between XPath queries and WSDL documents.

we associate each XPath query in a WSDL or WS-CDL document with the action that may use it.


In other words, when the thwart mechanism, started at i, fails in .nding a non-overloaded replica, then i decides to expand the overlay.

from this point on, initiator i becomes unavailable (preventing itself from participating in traversals): it chooses a node j outside the memory and actively replicates its timestamp and value at j.j becomes a replica, i shares a part of its own workload and responsibility zone, and j and i notify their neighbors becoming newly available.


HEALING ATOMICITY VIOLATIONS One of the common kinds of bugs causing apparent data races is a wrong atomicity assumption taken by a programmer.

the programmer forgets that there can be a thread switch in a certain place in the code, which may lead to severe consequences.


, Xr)T , while X consists of possibly correlated random variables [3].

pCA performs a linear transformation of input data into a new coordinate system.


This restriction is necessary so that there is no need to revoke resources from a thread.

we assume that threads within a single application behave cooperatively.


After such evaluation of the SLA, the guarantees speci.ed in the SLA are also evaluated.

when a metric of the SLA is violated (Event), a Condition might be veri.ed and the corresponding list of Actions is sent to the manager responsible for executing them.


we describe each action in the JMM as a guarded command.


Here, Perracotta missed the important edge between enlistResource and delistResource because whenever enlistResource is called, either delistResource or commitResources must be called.

a Resource does not have to be delisted.


parent s(a,b), and the combinators and their parents are also fused together.

in order for a and b to be fused together, c and d must be fused, a and c must be fused, and d and b must be fused.


Figure 9 presents an example of elementary and abstract components.

the elementary UI components of Filter1D , Filter2D , Filter3D and Timeline and two variants of task SelectFilter are shown.


While our .xed-point formulation is similar to the set of rules for lazy evaluation described in [12], it is new and more ef.cient.

the rules presented in [12] involve keeping tuples, where the tuple contains as many as 3k global variables, where k is the context-switching bound.


Recall that we have mined API candidates for each API query.

for an API query Qi,we have a set of API candidates, T 1, T 2, etc.


(.avg - .b) b.B and .b<.avg Intuitively, we attempt to migrate the extra nodes from gateway b* to underloaded gateways, based on their degrees of under-utilization.

more nodes will attempt to join the tree with fewer nodes.


If a solution f exists, then we can always produce an expression e( by adding annotations to e ( such that the algorithm succeeds for the typing problem (G, e, t) and that f is equivalent (for the equivalence induced by the moregeneral ordering) to the solution f0 computed by the algorithm.

even if the algorithm is not complete (because of the acyclicity condition) and makes a choice between mostgeneral solutions (the smallest one for the subtyping relation), for any solution to a typing problem, the programmer can always add annotations so that the algorithm infers this very solution (or an equivalent one).


In this paper, we propose an extension of existing refactoring techniques for feature-oriented programming (FOP), a compositional approach for product line development.

we make the following contributions: We point out limitations of traditional object-oriented refactorings for SPLs.


of Massachusetts Amherst, MA 01003 USA wise@cs.umass.edu  Julian Hadley Harvard Forest Harvard University Petersham, MA 01366 USA jhadley@fas.harvard.edu Aaron M. Ellison Harvard Forest Harvard University Petersham, MA 01366 USA aellison@fas.harvard.edu Emery Boose Harvard Forest Harvard University Petersham, MA 01366 USA boose@fas.harvard.edu ABSTRACT This paper describes our experiences in exploring the applicability of software engineering approaches to scientific data management problems.

this paper describes how process definition languages can be used to expedite production of scientific datasets as well as to generate documentation of their provenance.


Figure 3: Five level XML evolution architecture PSM components can be discovered and updated as well.

when someone decides that a customer s name is to be represented by two values (.rst and last name) instead of one string, it is possible to automatically .nd all relevant usages of this value and change all the a.ected XML schemas and the conceptual model at the same time.


Since most static analyses overapproximate program behavior, the reader may expect that the constraints f used in the abstraction are overapproximations.

if f * is a constraint describing some subset of elements in the container during a concrete execution, then f * .


A predicate .eld is a .eld of an object that is present (can be read and written) depending on the values of other .elds.

the structure of an object varies at run time depending on the values of its own .elds.


EF is the ratio of energy used by the scaled workload to energy used when workload is processed at full speed.

pn 2 i=1 vi fiti EF = 2 (4) vMAXfMAXT where vi and fi are the voltage and frequency of each period of time (ti) between two frequency scaling operations and T is the execution time of benchmark at full CPU performance level.


There- fore, in this paper, we explore the former approach.

we assume the availability of a dou-ble compare-and-swap (DCAS) instruction that can atomically access two independently-chosen memory locations.


This mechanism can be extended to Java framework resources.

we can determine different object classes inside Java framework and insert hooks in access points to objects of these classes to control access.


The fact that computational components do not move, or that they might move at most within a single interaction to execute a single task, allows for a simple binding between components and hosts.

it is statically possible to .gure out what is executing where, and this, in turn, allows for simpler con.guration, testing, deployment, and update of components as well as of entire applications.


ferent equivalence relations and use the singleton pattern [9] to guarantee that only a single instance of each semantically equivalent AST is created.

the behavior of Instance()re.ects the particular equivalence relation that the component implements and ensures that any two constructions of a semantically equivalent speci.cation share the exact same storage location.


In an optimal coloring, the chromatic number a(G; w) is related to the notion of heaviest path in an acyclic orientation of G as follows: a(G; w) = min (max w(µ)) (1) e.A(G) µ.P(e) where A(G) is the set of all acyclic orientations of G and P(a) the set of directed paths in an orientation a .A(G).

the orientation whose heaviest path is the smallest induces an optimal coloring.


While in a de-duplication based store, a chunk with a higher commonality would be more valuable.)

the amount of user data lost when a chunk i in the storage system is destroyed is given as follows [2]: lossi = commonalityi * chunksize (1) Based on the above analysis, we can see that guaranteeing high data reliability is a critical problem in de-duplicated storage systems.


Instead, since inTune is intended to enable and support coordination, its features are de.ned based on a substantial body of work in system controls and multi-agent systems.

in reference to distributed control theory and multi-agent systems for power engineering [25], inTune coordinators are similar to intelligent agents in that they are: (1) proactive, initiating their own local control actions, (2) reactive, such that they can react to local monitored events; (3) social, such that they communicate management actions with other coordinators; (4) autonomous, such that they have local control and treat external control as advisory .


2.3 The Inverse Method In [2], the inverse method (IM ) was proposed: given a PTA A, this semi-algorithm takes advantage of a reference point p, and generalizes it in the form of a tile, i.e., a linear constraint K on the parameters where the discrete behavior is uniform (see Figure 1a).

for any point p' satisfying K, the discrete behavior of A[p']isequal to thediscrete behavior of A[p].


Some of the actions could be e, a null or no-op action.

we assume that e E A~ for i = 1, ..., n. some attackers could be idle at some stages of the attack.


We expect these times to improve in the future as new wireless technologies and network optimizations are introduced, increasing the bandwidth of WiFi networks.

vM synthesis time is now directly correlated to network bandwidth.


While there can Programming lifecycle to such projects.

it focuses be many causes to such failures, one common problem is the gap on tools and techniques that facilitate progress amidst chaos and between expectations and implementation.


The ferret and dedup applications can be parallelized as simple pipelines with a .xed number of stages and a static dependency structure.

ferret uses the 3-stage SPS pipeline shown in Figure 1, while dedup uses a 4-stage SSPS pipeline as described in Figure 4.


However, the main di.culty is to .nd an e.cient mapping between a GPU thread and neighbor candidate solution(s).

the issue is to say which solution must be handled by which thread.


An essential aspect to achieve these goals is the ability to perceive changes in one s computational environments and to adapt to these changes in a seamless manner [1].


In practice, monitoring is often reduced to performing sanity checks at runtime while a system executes, such as building residuals, check-sums, or other single-state based assertions.

either some system action leads to a bad state , or not, irregardless of the history of actions.


As the relation of related values at bool implies ß-equivalence, d0.0 (m) m1 m2 is equivalent to d0 .0(m) m1 m2 despite the di.erence in the arguments.

m is a constant function, or its argument does not interfere with its output.


The typing judgments C f C enforce that no name is de.ned twice, and that de.nitions use correct typings.

global variables must have function-free types (notated as .-free), functions must be typable with the type they declare, and the render and init functions must be typeable under the corresponding effect.


Assignee experience: Univariate and multivariate analyses show that this variable is significant in two out of three projects.

the coefficients values are negative in all cases.


In response to this problem, this paper proposes a novel method Invariant Refinement Method (IRM) for systematical derivation of an EBCS-based RDS architecture from high-level requirements.

iRM builds on gradual refinement of invariants that are employed as a concept for reflecting both requirements and architectural elements.


(ListD A) which inserts the .eld leq and re.nes the index of the recursive position to a.

the underlying description for OrdList is lOrdListOD A .A J : Desc A (so OrdList A .A b desugars to µ lOrdListOD A .A J b), and IOrdListOD A .A J : Orn !


The Internet provides one avenue for collecting observations about the use of software in the field at minimal cost.

data about applications' use can be extracted from events reflecting end users' interaction with software.


Our results show that inconsistent policy con.gurations happen frequently and lead to security vulnerabilities.

we detected several insecure usages of the browser components that disable default protection mechanisms of IE 9.


However, if SR is the top level, then the top-level SR Director needs to regulate the passage of time, e.ectively acquiring DE semantics.

it cannot abstract away the passage of time if its submodels have to be concrete about the passage of time.


This makes the Perl slice much easier to use in debugging than the original recording, because the execution of the rest of the system can be modi.ed without affecting replay.

the Perl interpreter s execution can vary from the original run, and this allows the programmer to use the debugging features of the interpreter, such as breakpoints.


Thus, a single representative edge can be shared across all dynamic instances of an exercised dependence.

in these situations there is an one-to-one correspondence between all execution instances of a pair of statements involved in a dependence because the statements involved are local to the same basic block.


We consider a variability-aware parser as sound and complete if it yields a parse result that correctly represents the variability of the parsed code fragment.

it should not matter whether we (a) .rst generate the source code of one variant (with a standard preprocessor given a desired feature selection) and then parse that variant with a standard parser or (b) .rst parse the unpreprocessed code with a variabilityaware parser and then generate the abstract syntax tree of the variant (by pruning subtrees not relevant for the desired feature selection).


Therefore, the scalable pMIX schemes are focused only on selected number of threads across selected number of cores.

two pair of threads are chosen from four cores on di.erent LLCs in pMIX: two of which have the most LLC misses, i.e., heavy cores, while two others have the least LLC misses, i.e., light cores.


One of the very important features of roBDD is that it can represent a unique set by one unique (integer) number and from that number the full set can be easily retrieved from the roBDD.

by using roBDD we are able to represent a slice by one integer.


Withapplication-layer request routing, the task of selecting the surrogate server is typically carried out by a layer 7 application, or by the contacted web-server itself.

in the presence of a web-server routing mechanism the server can decide to either serve or redirect a client request to a remote node.


a static checker for proving certain properties of SCJ applications [10] and a Technology Compatibility Kit [11].


Compensation refers to the regulation of loss.

the use of compensatory or substitute mechanisms to prevent or balance agerelated changes.


Similarly, rule (iii) introduces aggregates.

it de.nes a function (average) to be applied to a speci.ed set of values (temperature readings in the last 3 minutes) to calculate the value to be carried by the complex event.


Of more interest, from a re-con.guration point of view, is when the price/performance ratio is more advantageous for large VMtypes.

this e.ect can be large when there is a penalty associated with having large number of VMs.


Since C does not support exceptions, users must handle them by hand.

when an exception is raised, the C code must clean up resources such as acquired locks, and unwind call frames until it .nds an exception handler or exit.


When Hinze considered backtracking with the Prolog-like cut , the derivations of the two monad transformer implementations fail to follow the suggested reasoning principles.

the term-based monad transformer is not based on free algebra; the context-passing implementation has to patternmatch on the context and hence cannot be in a continuation-passing style.


As a result, the bene.ts discussed in Section III can be exploited.

the run-time of the underlying solving engines can signi.cantly be improved as shown by the experimental evaluation in the next section.


We explicitly capture various constraints among base and aspectual use cases.

we transform aspect-oriented use case diagrams and descriptions into aspect-oriented Petri nets.


Recall that the heap-graph contains only module owned objects.

this de.nition does not consider pointers to exposed objects that may be stored in client objects From Theorem 3.1 and Theorem 4.1 we conclude the following.


For instance use case Process bids follows section SupplierA Bid OR SupplierB Bid OR SupplierC Bid interpretation is that Process bids can be executed whenever any of use cases SupplierA Bid , SupplierB Bid or SupplierC Bid has reached a point where Process Bids is enabled.

the three use cases execution is not synchronized.


When M and d are appropriately large, the polygon for each target node may become suf.ciently small so that accurate estimation canbe achieved.

we emphasizethat accuracyis affected notonlyby the numberof anchors M, but also by the number of events d. MSPprovides a tradeoffbetween thephysical cost of anchors and the soft cost of events.


The key difference is that rather than using row types, standard effect polymorphism admits a union operation on effect types.

it is possible to express an effect as the union of several effect variables.


These results, presented in Figure 5, indicate that the average total energy savings we obtain over the DMO and TMO schemes are 6.8% and 13.8%, respectively.

our approach has an important impact on overall energy consumption during application execution.


A secure/con.ict check should be implemented for GM (n) after an update of GM such as: (1) when a user is added to an existing group; (2) when a privilege is added to an existing role or an arc is add to LRP ; (3) when a new group or a new role is created; (4) when an arc is inserted in LU R ; and (5) a new con.ict constraint is added.

if TC (n) n G M CM = Ø holds, then the operation is legal.


designed infrastructure that considers performance, cost-effectiveness and system reliability.

using interactive nodes alone will suffer from performance and stability issues.


In order to deal with this complexity, we use the notion of architectural views [10] to describe the various SOA concerns.

a view is a representation of one particular concern of a process.


INTRODUCTION The engineering community has witnessed a paradigm shift from centralized to distributed system design, propelled by advances in networking and low-cost, high performance embedded systems.

this has led to signi.cant interest in the design and analysis of multi-agent networks.


The risk level related to the hazard is intolerable without mitigation actions.

either the consequence or the probability of the realization of the hazard needs to be mitigated.


The main underlying idea is that existing test cases encapsulate domain knowledge, and thus can be reused to generate new test setup actions, inputs, and oracles without the need of complete speci.cations.

i focus on the test cases written in the same language of the software under test, for example JUnit test cases for Java.


When the host allocates a buffer object by invoking clCreateBuffer(), our virtual GPU device thread allocates the requested buffer in the virtual device memory.

it allocates a buffer in the host main memory and inserts the buffer into the list.


We were also able to use unique pointers as capabilities for building further memory-management abstractions.

we used unique pointers to control access to a form of dynamicallyscoped arenas [18], and for building reference-counted objects and arenas.


The BorderWindow class overrides paint, but its own implementation should never be overridden completely in later subclasses.

beta more neatly implements the paint method for BorderWindow, so we annotate the implementation with beta and use inner in the body: class BorderWindow extends Window { ... beta void paint() {super.paint(); // paint background .


Note that each additional (potential) recovery task, while improving the reliability, reduces the available slack for DVFS and limits the opportunities for scaling down frequencies.

the problem mandates an e.cient technique in three-dimensional timing, energy, and reliability space to satisfy all the constraints.


Currently we are working on extensions of JAG to other temporal properties.

we currently address the veri.cation of properties expressed by B¨uchi automata.


Our results found that object pools are a powerful abstraction for guiding exploration, orthogonal to the path-bounding approaches used by tools such as Pex.

even a naive implementation of object pools helped Pex enumerate structures and .nd bugs faster.


dimap g j (D-C O M P) A type functor is a difunctor with the same parameter in the covariant and contravariant positions.

if F is a type functor, then t°(a) = F a a, and dimap can be simpli.ed: dimap : .a b.


The key idea of the technique is to express the semantics of each basic block in a program using Boolean logic, followed by inferring pre-and postconditions for each block through interleaved forward and backward analysis.

the technique relies on register-wise value-set abstractions, which are subsequently re.ned using alternating forward and backward analyses.


In addition, the idea of telepointer prediction is one that presents a number of additional possibilities for improving networked groupware.

we argue that the display of a telepointer can be de-coupled from the sampling and sending of the position information.


Our language design aims at helping in this regard by avoiding constructs that could become expensive.

unless register allocation requires spills (which is very rare), memory allocation and memory access are never implicit but always syntactically apparent.


In the clusterworkloads atYahoo!, we .nd that,a small fraction of the daily workload (about 5% of the jobs) use well over 90% of the cluster s resources.

these jobs (1) involve thousands of tasks that are run on many machines in the cluster, (2) run for several hours processing multiple terabytes of input, and (3) generate intermediate data that is at least as big as the input.


Although Garcia s type system is quite permissive, thereby providing expressiveness, the type system is not modular.

type checking a code fragment does not mean that all uses of the code fragment will be well typed.


Instead, we will use them for monitoring.

we will attach skill prerequisites to each sub-goal and monitor for those pre-requisites being met.


the empty learner is not queryable, since it contains empty tables.


Though they seem to be extremely useful when writing and editing specifications, there seems to be difficulty reading specifications with macros, which we would like to address in future work.

we would like to investigate how various levels of modularization (i.e.


The aim of this research, of which this study is a part, is to improve the process of constraint definition as part of domain specific CASE tool specification in a meta-CASE tool.

the work focuses on facilitating and simplifying the constraint definition process using Specification by Example (SBE) technique which based on the notion of well-known technique programming by example (PBE).


In experiments, VMs are con.gured to use the work-conserving mode [23].

the shares are merely guarantees, and a VM is eligible to receive extra CPU time if other VMs are blocked or idle.


Jouppi investigated various cache policies and their effect on performance [21].

write-validate offered the best performance it combines no-fetch-on-write and write-allocate.


It may help potential contributors to gauge the general interest in a project, and thus determine if they should participate [4].

the number of forks may be a.ected by the number of watchers.


We show in Appendix A that for a memory hierarchy with N cache levels (L1, L2, L3,..., LN, memory) and a miss cluster of C + N Csize C, there are (5) Pr[H]=1 -p. Then the probability of a miss in the ith Mi Mi = = .

cluster is pi Mi+Hi Ti The L2 miss ratio p is related to the miss ratios of the individual clusters in the following manner, p = M = 1 Mi M1 (T1 (T2 MN (TN = T )+ M2 T )+... T ) T T1 T2 TN =p1(TT 1 )+p2(TT 2 )+p3(TT 3 )+...pN(TT N ) the miss ratio is the weighted sum of the miss ratios for each miss cluster size, where the weights are the probabilities of a hit or miss to a given cluster size.


When the ufunc is applied, all dimensions with a size of one will be broadcasted in the NumPy terminology.

the array will be duplicated along the broadcasted dimension (Fig.


Say we wish to have streams that can be passed to multiple threads of execution with the requirement that consumption of each element of the stream may occur once and only once.

operations on the stream must have a side-e.ect on the stream.


http://dx.doi.org/10.1145/2502081.2502114  Hans Stokking TNO Netherlands Organisation for Applied Scientific Research Brassersplein 2, Delft (the Netherlands) +31 88 86 67278 hans.stokking@tno.nl However, realizing those shared interactive services faces a lot of challenges [2].

this paper focuses on the provisioning of synchronized playout in all the involved consumer devices.


SAFETY In this section we discuss our su.cient condition for safely introducing a cache at an allocation site s. The introduction of a cache at an allocation site (to implement hash-consing style ob ject-sharing) can be said to be safe if the refactoring causes no change in the observable behavior of the program.

whenever a newly created ob ject or is replaced by another object os that is in the cache, the rest of the run is identical to the rest of the run had the replacement not occurred, in terms of both the sequence of instructions executed, as well as the updates to the state of the program performed by corresponding pairs of instructions in the two runs.


Although their model is similar to the one presented here, there is con- siderable difference in the focus of the work.

their model formalizes a reconfiguration language for use within a configuration management framework.


For each IC we create a view that returns a non-empty result if and only if the IC has been violated during the transaction.

the tuples retrieved querying the view are the ones violating the IC.


In discussing the construction of HaRe and Wrangler, we comment on the different challenges presented by Haskell and Erlang due to their differences in syntax, semantics and pragmatics.

we examine the sorts of analysis that underlie our systems.


Second, it provides a Bayesian technique to re-estimate probabilities, which can be applied to different formal models (such as DTMCs or QNs).

a running example is used to illustrate the approach in the context of reliability modeling via DTMC [20].


FUTURE WORK In this paper, I provided a sketch of the commonly assumed planning model and its special properties in comparison to other classical planning problems.

i pointed out that, in contrast to classical planning problems, there is an in.nite set of ob jects in automated software composition, that objects have no extralogical built-in semantics, and that there are restrictions on the planning order.


All other events are called non-local events.

the set of events E is partitioned into the set of local events, EL, and the set of non-local events, EN L .


In our projects, when a user story was selected for implementation in the current iteration, we modeled what misuse stories could be related to the user story.

the fundamental question was: how can this functionality be misused?


[fl2] Figure 10:Transition rules modeling spontaneous failures.

for a con.guration to be well-formed, every trans- rations will correspond to transactors whose states are inconsistent actor t musthaveitsown historyinits state dependencemapandits dueto nodefailures.


The depth of the input tree provides a natural upper bound on the length of the XPath to be synthesized and on the unwinding of recursive traversals of the input tree.

the WE B SY N TH interpreter is self-.nitizing with respect to the structure of the input tree.


Our goal is to study extended inverses and maximum extended recoveries of such schema mappings.

we will also investigate the language needed to express maximum extended recoveries.


4.1 Removing dead memory operations As mentioned, memory operations are predicated and should execute only when the run-time value of the predi- cate is "true".

a side-effect operation having a constant "false" predicate can be completely removed by the compiler from the program; its token input is connected to its token output.


a set of models which are coupled with the considered metamodel by means of the dependsOn relation.

the generative component (GMF Tooling) of GMF supports a model-driven process (see Figure 4) for generating a fully functional graphical editor starting from the following models: the domain model is the Ecore-based metamodel of the language for which representation and editing have to be provided;  the graphical de.nition model contains part of the concrete syntax; it identi.es graphical elements that may, in fact, be reused for different editors;  the tooling de.nition model contains another part of the concrete syntax; it contributes to palettes, menus, toolbars, and other periphery of the editor;  ideally, the aforementioned models must be reusable as they do not contain references to each other.


For each IND the attribute sequences on the LHS and RHS of IND must be specified.

for a RIC on the RHS is specified a key of referenced relation scheme and for an IRIC on the LHS is specified a key of referencing relation scheme, instead of arbitrary attribute sequence.


Special features have been introduced for updating quantum arrays.

a replacing construct makes it possible to update individual entries within quantum arrays.


Therefore, most of the nodes handle most of the subscriptions, while only a small set of nodes, namely those placed in the middle of the tree (i.e., at the lowest levels) dispatch most of the events.

figure 9(b) shows that the maximum forwarding load due to events is incurred by the nodes on the second level.


The second is developing novel approaches to some of the more challenging aspects of the veri.cation.

our formally veri.ed compiler can bootstrap itself: we apply the veri.ed compiler to itself to produce a veri.ed machine-code implementation of the compiler.


These two situations are really the same.

at the point in time when the representation is being generated, it is not known which alternative is going to be chosen for a product and so the alternatives have to be captured.


The last phase is the actual data transmission phase.

in Initial Fraction Exchange Phase (Algorithm 1), each node v determines the number of neighbors .v that will send data to v.kv = |Pd(v)|represents the number of neighbors of v that have either a smaller hop-distance from the source or the same hopdistance but a smaller id.


4.2.1 Variant 1: Impose Safe State before Resume This variant essentially .nishes the fragmenting and reassembling aspects before unbinding them from the application.

the mechanism to preserve global state consistency is used to preserve structural integrity.


We catalogue problems according to their local proof complexities, and we show that the LCP(f) classes form a natural hierarchy of decision problems.

there are natural graph problems that separate the following levels of the hierarchy: LCP(0), LCP(O(1)), LCP(O(log n)), and LCP(poly(n)); see Table 1.


statement) has been covered by test cases.

100% statement coverage does not guarantee the 100% of fault detection.


user request query type and context A series of experiments were conducted to evaluate the potential bene.ts of the XSnippet system.

the experiments were designed to test the following hypotheses: Hypothesis 1: Generalized queries, IQG, provide better coverage of tasks than the specialized queries IQT and IQP (see Section 6.2 for results).


However,in ordertodobetter thanrandom guessing, p must use information from probesperformedby at least(n/B)-1 other players.

ideally, player p would collaborate with the (n/B)- 1 players that have preferences most similar to p. player p would collaborate with a set of players P with minimum diameter.


Consider an until-loop and the following statement: until(E){S}; T. Inside the body S, E has been evaluated to false, so there are no bindings in S from E. However, if control ever passes to T, then E must have evaluated to true.

the test in an until loop introduces bindings after the loop.


CONFIGURATION A configuration is a series of commands in order to generate executable files (with compilers and linkers) from the given source files.

a configuration determines which set of source files is used to generate an executable file, or which options will be passed to a compiler or a linker, etc.


The total time complexity is the sum of #firedTimes over all rules, minimized symbolically with respect to the given sizes and the constraints.

if a relative argument size is needed but not given, we use the corresponding nonrelative argument size; if an argument size #P.I is used but not given, we use the minimum of (i) the product of domain sizes for arguments of P that are in I and (ii) the argument size of P for arguments that are a superset of I,if given.


The simplicity of the ATmega16 microcontroller facilitates the design of high-integrity real-time applications.

the context switch and interrupt handling procedures are simpli.ed.


WeBWorK [7,33]is a web-basedapplication that allows teachers to post math or physics problems for their students to solve online.

teacher-supplied WeBWorK problems are interpreted by the application server as contentgeneratingscripts.Itis uniquefromtraditional web applications in its collaborative content considered by some a distinctive Web2.0 feature.Speci.cally,its requestprocessingisheavily dependent on content supplied by end users teachers in this case.OurWeBWorKinstallation runsApache2.2.8 web server, a variety of Perl PHP modules, and the Moodle course management system [2].


SYSTEM OVERVIEW Programming in a start-up environment.

the Since much of our work is in the area of data communications, we challenges of meeting and adapting to evolving requirements are have developed an application framework that can be extended to presented.


In our running example, the va_fptr value representing printf would have the following type:4 val printf : (string, sint) va_fptr A use of printf with an int and a double argument then looks like this.

va_call printf (va_ml_sint o va_ml_double) "x=%d y=%f" 3 Math.pi the instantiated printf (without its arguments) has the following type.


The results we show here can be used to open the way for a series of comprehensive studies of the performances of various automated testing strategies.

the algorithms identi.ed here to produce the best results for random testing should be used as the basis for comparison against any other strategy.


In computing DS graphs as de.ned above, the naming scheme used to distinguish heap objects can have a strong in.uence on the outcome of transformations such as Pool Allocation and Pointer Compression, both of which focus on heap objects.

in order to segregate distinct data structures into separate pools (and apply pointercompression to each data structure separately), the pointer analysis must use a fully context-sensitive naming scheme for heap objects, i.e., distinguish heap objects by acyclic call paths.


This drastically reduces the amount of false positives reported, making the tool usable for the debugging of large C++ applications.

the amount of false positives removed by our improvements during our experiments was in the range of 65% to 81% of the total number of warnings.


The latter process seeks to find an object that is known to exist, is well defined, and can only be located in a limited number of places.

software developers acquire an understanding of what they are looking for by searching.


For example, the simple pseudo-English statement  p lnpaD td op Enggioth sta a e mtnDp tgtp tmDnpgnid m can be automatically expanded into the more arcane formal statement: t D Dp tgte xDnpegn eio m e m aDdpegn eio m D tn (p Ea nggiot= sDdpegn eio m One drawback with temporal logic patterns is that while complex temporal formula can be automatically generated from intuitive pseudo-English, the execution cost remains.

even though we can quickly build the properties model, we may not be able to explore all of that model.


In a formula that p translates from a pattern, only features are de.ned that decide whether the tree s code element exists with a particular identi.er.

all features that are not inside the pattern remain unde.ned in the translated formula.


Ouranalysishas certainlimitationsthatmayaffectthe validity of our results.

our implementation only analyzes code that is reachable either from top-level statements or from the DOM.


THE STATE OF PLAY Changes to the urban fabric share some of the same characteristics as new software applications, whether at the relatively small scale of a new public sculpture or the very large scale of new buildings, parks, roads, or entire new districts.

they present overlapping issues specifically around the question of participation.


In some network scenarios, the topology and costs are common knowledge.

the sender knows in advance the path that its packet will take and the costs on that path.


(S ' ; e ' ) is not as restrictive a requirement as it appears to be at .rst glance: it is .ne for S '' to contain bindings for locations that are bound in S ', as long as they are also locations bound in S. In fact, they may even be locations that were updated in the transition from (S; e) to (S ' ; e ' ), as long as they were not created during that transition.

given a store S '' that is noncon.icting with (S; e) "-.


At best, today s leading software engineering processes ignore components, and at worst they can be regarded as being incompatible with them.

the state-of-the-art in software processes has effectively become decoupled from the state-of-the-art in software architectures.


Following up with the previous example, let s say that S1.a1 is of type java.lang.String.

in this case, the next example demonstrates how to invoke a method in the stream s attribute a1: SELECT a1.f1.toString() FROM S1 Invoking a complex type s constructor creates a new stream attribute of the type, as in the following example: SELECT java.lang.String( foo ) as a1 FROM S1 a new object of type String is created and associated as the value of the attribute a1 of the output stream of the query.


ODI synopses are small-size digests of the partial results received at a node such that any particular sensor reading is accounted for only once.

the synopsis at a node is the same regardless of (1) the order in which readings or partial results are received at the node, and (2) the number of times a given reading from a given sensor arrives at the node (either directly or indirectly via partial results).


During the time intervals within sync points, asynchronous events for a process are delivered instantly and need not be deferred.

on average, most of the time asynchronous events can be delivered promptly; and if not, then they are delayed for a short period.


The paper has presented PaaSage s approach, which essentially aims at extending the capabilities of the developer to generate efficient cloud applications.

builds a combined programming and execution environment that incorporates this expertise throughout the whole lifecycle.


Our .rst observation is that the bug in AcctRecv can be caught if we know that there exists a feasible trace in which CommitQ is executed and SaveAcct is either not called or is invoked, but failed.

we can abstract away the relative order of individual actions, and only consider the set of actions that executed successfully.


In this study, we measure the sensitivity of the knapsack-derived schedules to variations in the prescribed allocation policies and their corresponding utility functions.

we explore the e.ects of varying the strengths of an external user-speci.ed monetary metric, an intrinsic estimated response time mediated by nearness to completion time metric, and of varying the shape of a sigmoidal normalizing utility function.


An architectural mismatch occurs when the assumptions that a component makes about another component do not match.

the assumptions associated with the service provided by the component are different from the assumptions associated with the services required by the component for behaving as specified [8].


The simplicity of our technique rests on a deliberate restriction.

parent and position information provides read-only context along traversal.Without this restriction, we were mixing purely functional SYB style with mutable updates.


In this work, we introduce probabilistic analysis into the design of speculation schemes.

by tackling applications that are based on Finite State Machine (FSM) which have the most prevalent dependences among all programs, we show that the obstacles for e.ective speculation can be much better handled with rigor.


Informally, our result states that if we are to build a mutual exclusion algorithm or a linearizable algorithm, then in certain sequential executions of that algorithm, we must use either RAW or AWAR.

if all executions of the algorithm do not use RAW or AWAR, then the algorithm is incorrect.


Tony Clark School of Engineering and Information Sciences University of Middlesex, London, UK http://www.eis.mdx.ac.uk/staffpages/tonyclark/ t.n.clark@mdx.ac.uk The development of Gmodel relates to the second objective of the KISS initiative [3], and builds on the KISS results that have been achieved in 2009 [4].

gmodel represents an attempt to provide explicit tool support for the full set of KISS principles: 1.


Figure 5 shows that of all the changes that occur in the application between 20% and 40% occur when methods are cloned.


However, there has been little study of strategies which can be employed by participants to maximize occupancy and therefore utilization.

providers may implement strategies regarding bidding time, and policies relating to oversubscribing resources.


The skip symbol matches exactly under the conditions that cause all declared symbols to fail to match.

if an event is not matched by any declared symbol, then it is matched by skip.


This is a technique for reverse engineering that uses the morphology, or external interface of an application to uncover the ontology1 of an application, or the application s theory of the world .

the message in the medium includes that a design is not neutral and reflects a 1 In computer science, an ontology is a data model that represents a set of concepts within a domain and the relationships between those concepts.


This policy states that the energy contributed by software principal i is equal to the total energy consumption divided by the number of software principals.

each software principal gets an equal share of the total energy consumption.


also expresses reachability, except (1) its target needs to satisfy (ret)R1, and (2) this target needs to lie in the same procedural context as s ' .

we want to express what we call local reachability of (ret )R1.


Fm-ther to our ex- amplej we assume that the payment is undertaken using the purchase protocol from the Common Eletronic Purse Specifi- cations (CEPS).

the security then relies on the correctness of the purchase transactions protocol, whose ab- stract specification is given in Figure 4.


Better approaches for showing large data types are needed.

an interactive web-based viewer with hyperlinks to close or expand sub-values would be particularly useful.


However, this interpretation is obviously wrong, since passing, say, a String to m would make the program crash at the invocation of intValue().


Dynamic operations are dif.cult to implement as ef.ciently as static operations.

it is not clear how to use the type system to pass only the relevant effects to each scope.


To fulfill typical change requests developers need to translate them into terms of source code.

they firstly have to locate the source code components that are responsible for feature functionality, and secondly they need to understand how these components interact.


A interpreting is as pure domain equality does not destroy continuity of the interpretation transformer, as the whole evaluation of constraints in the guards is inside an existential closure.


The information we need to keep for restoring the JVM state at the region boundary should be basically the same for all three options above, but the way to reconstruct the new stack frame is different.

the first two options need to create a set of stack frames according to the inlined context at the transfer point, while the third option can simply create a single new stack frame.


Furthermore, we shifted the focus on further improving the tool.

in this cycle the main emphasis was on interface design as countermeasure graphs documented in the tool grew, i.e.


ways to assign registers to the live ranges.

as long as the 3 live ranges are assigned to different registers, the solution is acceptable for a traditional register allocator.


The policy with respect to this packet (and similar ones) is invariant.

every subsequent time the system evaluates the policy against this packet, it will return the same set of forwarding actions.


In particular, if the two calls to deposit1 are interleaved, the .nal value of balance may re.ect only one of the two deposits made to the account, which is clearly not the intended behavior of the program.

the program contains a race condition: two threads attempt to manipulate the .eld deposit1 simultaneously, with incorrect results.


Properties In this section we investigate the properties of our algorithm.

we establish that it infers a maximal well-typing and that theoretically it may not terminate.


Such baseline data can be useful, for example, in replication studies that involve di.erent subjects and for which the sets of mutants and test cases may therefore di.er.

we are interested to establish baseline data for the sizes of the SSHOM and SSHOMsRed sets, since these are comparatively less well studied than .rst order mutants (the FOM set).


4.1 Modeling language idea BPEL is just one of many languages, and for us language is just a way to solve the requirements.

the requirements are the most important thing.


Again, ..equal to 0 reflects the case where the valuation of V::plan is at each time instant up-to-date with respect to the current valuation of P::availability of the parking lots and V::planFeasibility of the vehicle.

the associated computation activity computes infinitely fast and infinitely often.


Here, each simulation preserves the running time of an algorithm up to a constant factor.

together with Step 1, this will imply the O(.)


4.1 Capabilities Our goal is to de.ne and enforce a notion of con-freeness for a program, rather than a program state.

we wish to determine for a particular update whether it will be acceptable to update some type t. An update to t will be unacceptable if an occurrence of cont exists in any old code evaluated in the continuation of the update.


As a just-in-time compiler, HHVM has access to the runtime values .owing through the program.

the tracelet abstraction, described in detail in Section 4.2, enables HHVM to exploit type regularities that cannot be proven statically.


Implementing guarded receive with CML is unexpectedly complex for such a relatively straightforward operation (Donnelly and Fluet 2006).

a CML-style guarded receive is inherently non-modular, because the protocol requires the participation of both the sender and the receiver.


Looking only at these new vulnerabilities, we see that fewer than half (41.5%) of them were disclosed during the current lifetime of the originating version.

while vulnerabilities are found in the code that is introduced each RRC iteration, the overwhelming ma jority of them are not found during the 6-week period following their initial release.


Since the interval of the progressive increase is small and the increase for each payload bit stops immediately when the corresponding payload bit is successfully embedded, the amount of correlation value over the detection threshold, denoted as D in the prescribed DII spreadspectrum watermarking model, will be small.

all the payload bits are embedded weakly, but all of them can be extracted when the pre-negotiated manipulations are performed on the marked work before extraction is performed.


The unique resource constraints imposed by technologies like geosensor networks mean that traditional, centralized approaches to spatial computation are inef.cient and not scalable.

technologies like geosensor networks typically impose high costs on communicating data between nodes (e.g., due to limited node energy), compared with relatively low costs of processing data at the node itself (necessitating so-called in-network processing) (cf.


This also provides a nice opportunity for sanity checking --for example, if the current instruction branches back to another instruction for which the stack depth has already been cal- culated, then we can check whether the expected stack depth matches the current stack depth.

a given instruction could be the target of multiple other instructions and the stack depth at all of those instructions must be consistent (oth- erwise, this indicates an error in the code genera- tor).


we next observe that pointers in a layer r are not useful in realizing any edge in a layer l>r.if xis a pointer in layer l,and (x,y) is a realizable pair, then there is an execution sequence that realizes this pair without using any pointer in a layer r<l.


Finally, we do not distinguish between substitution and equality constraints, so the third has no effect on the .nal outcome.

the consistent solved form constraint store (if it exists), is unique up to renaming of existential type variables.


We then studied the text for possible discussions on other concepts not directly related to the de.nition from that particular study, but used in or related to other de.nitions.

whenever an additional concept was found in one of the publications, we re-examined all other studies to determine whether that concept was discussed there as well.


However, our end goals are very different.

they focus on the privacy implications and observe that a small number of administrative entities (e.g., Google, Microsoft) have broad insights into web access patterns.


The code relies on several library functions to access the database and to perform GUI operations.

the function sql_exec returns a cursor to the result of an SQL query, the functions sql_cursor_... access the relation underlying the cursor, and the gui_... functions create and manipulate appropriate GUI widgets.


The resulting modelling context [3], in which the software engineering is discussed throughout this work, is depicted in Figure 1.

the individual(s) decide(s) the part of reality on which they will focus and the elements that should be translated into a graphical representation and become explicit in the model.


The uniform encoding allows us to de.ne functions that work on all regular datatypes.

we can now de.ne a generic map function by declaring the following instances of the class Functor: class Functor f where fmap :: (a .


For instance, instead of trying to request explicit check Random_access for pointer type T* individually for each type T, it is better to write the assertion in a template form assert template Random_access with { T*::value_type = T; // T* s value type is T }; With that assertion, when the compiler needs to evaluate Random_access for a given type argument A it .rst (internally) generates the equivalent of assert Random_access with { A*::value_type = A; }; then evaluate that assertion, like in a non-template case.

the program is erroneous if the generated assertion fails.


Assuming that the graph G has a max-min LP associated with it, the max-min LP associated with the unfolding G ' is de.ned by inheritance from the parent nodes and edges.

the type of each node (agent, constraint, objective) is thetype of the parent node, and the coe.cients associated with the edges (aiv , ckv )are inherited from the parent edges.


First, our algebraic rules say very little about how multiple threads interact with one another during program execution.

a different instruction order may be chosen each time particular code is executed.


Multiple simulated architectural devices will be tied together into a distributed network simulation using an approach similar to that we used in our previous work [9].

we will use Lamport clock-style message timestamps to propagate message transmission and reception times.


Bugs Increase As Inter-Module Dependencies Grow Most development groups that we have seen try functional testing were motivated primarily by a desire to reduce bugs.

when they hear the phrase functional testing, they particularly focus on the word testing.


After the partitioning, data must be remapped among all the processes for the MPI implementation.

each process may have to send/receive messages to obtain the data that corresponds to its assigned partition.


This perspective sheds some new light on some oftbe terminology being used to describe AO.

an aspect at the pregram representatien level is defined as a modular unit of crosscuteng implementatien.


Further work will also be done to refine the implementation of the ART framework.

constraints will be included to represent some trade-offs, e.g.


Do they keep strong territoriality over the code base?

are most .les modi.ed by only one developer?


Some traditional mutation operators can be merged in one mutation operator in Smalltalk because operators such as + or -, which have a special treatment in most programming languages, are treated the same as other messages.


This separation of concerns (Dij76) is a ubiquitous and useful technique in developing programs.

we can extend our architecture by including .nal users linked with the system via mobile devices.


These lines in turn are controlled by the if at lines 41, 44 and 47 respectively.

a .tness based on approach level and branch distance has no guidance to reach the line 57 and thus the three if controlledbyline57,forexample,theifatline60.


The results of the evaluation of the metrics allow for the identification of a possible misalignment.

they provide a misalignment degree giving a measure of the extent at which the software systems used in a business process supports it.


To address this limitation, QLinux employs a CPU scheduler that pro- vides predictable performance even in the presence of fluctuating processor bandwidth.

the fair- ness guarantees provided by the CPU scheduler hold even when a varying amount of CPU bandwidth is used up by kernel tasks, thereby resulting in more predictable allocation [8].


Since each specialized code version is restricted to being executed in only a subset of the possible phases, the checks it has to perform in order to determine the current phase and what to do in this phase can be reduced.

if a specialized code version is only executed in the idle phase, for which no barrier action is required, the barrier code can be entirely eliminated in this specialized code version.


Therefore the lock set held by a thread T is the union of the lock sets held in the activation records of the thread.


Our .ndings disagree with those of Aspinall and Sevcik [3, 25] on the causality tests 17 18 and on the transform test T5.

we found that the original JMM allows both tests 17 and 18.


Restricting the application of Ai to subsets generated by Ai-1, instead of the entire program, improves its scalability.


While it is possible to change values in OpenDHT by removing the old value and putting a new one, such operations can lead to periods of inconsistency.

when two clients change a value simultaneously, OpenDHT may end up storing both new values.


3.2 Context The context of the experiment was constituted of students in Computer Science at the University of Basilicata.

27 students were from a Software Engineering course of the Bachelor program, while 9 students were from a Computer Graphics course of the Master program.


Kaufman-Broeckx Linearization We also investigate a formulation by Kaufman and Broeckx [14] that is minimal in terms of new variables.

instead of the n4 variables yki£j only n2 variables In these cases, we use the formulations as described above.


These quantitatively enriched models could then be translated into a service level agreement, which governs the way how con- tainers execute components.

containers could then monitor their actual performance, reliability and seal- ability and compare it with the required quality of service expressed defined in the service level agreement.


Its key novelty stems from the decoupling of update operations: they are split into one transaction that modi.es the abstraction state and multiple ones that restructure its tree implementation in the background.

the speculation-friendly tree is shown correct, reusable and it speeds up a transaction-based travel reservation applicationbyupto3.5×.


The update function thus needs to have the optimality function opt in the root of the expression selecting the optimal solution is the last step of its computation.

the syntactic form of the update function thus must be update(x,y,aval) := opt(f1(x,y,aval),...,fk(x,y,aval)); where functions fi compute the values of legal solutions.


The idea is that each controller pattern represents some coordination behaviour that manages a group of processing components in terms of the order of their execution and data exchange.

controller patterns encapsulate control .ow and data .ow to coordinate a group of processing components.


4  3.2 Technological Adequacy For answering the second question, Q2, the measurement framework analyses the adequacy of the support provided by the software system to the business activities, artefacts and actors.

the considered metrics are: Activity Adequacy (AA), Artefact Adequacy (AtfA), Actor Adequacy (ActorA).


Step 3: Building trees The .nal step of the linking algorithm builds path instances from the individual links, then aggregates them into path patterns.

if step (2) .nds the relationships shown in Figure 4(a), it would generate the two causal path instances shown in Figure 4(b), with the following probabilities: p1 = 0.8 · 0.9 · (1 -0.2) · (1 -0.1) · (1 -0.48) 0.270 p2 = 0.8 · 0.9 · (1 -0.2) · (1 -0.1) · 0.48 0.249 Each causal link included contributes a factor p corresponding to its probability.


A certi.er decides some other property P.M.

the certi.er is sound with respect to policy P ' if and only if P.P ' .sound certi.ers accept only policy-adherent programs.


For instance, a typical case in practice is that at the beginning, product line core assets are extracted from existing products (following the extractive approach) and then the core assets are updated and extended to develop new product variants (following the reactive approach).

the variability code may evolve either before or after the evolution of the variability model.


With ID and the accompanying Java compiler extensions, it is possible to generate method calls that are resolved at run-time by user-provided code.

iD introduces the ability to specify arbitrary method lookup semantics including changing late-bound methods.


A weighted element is simply a pair associating an object of unspeci.ed type with a value indicating the membership degree of the object in the concern.


From the approaches, it is not too di.cult to infer a correlation between the amount of human e.ort required and the performance.

the less (or more) human e.ort involved in an approach, the more (or less) complex the approach will be.


The analysis is performed on the pattern p ' of the relation erase(t,p,p ' ).

indeed, this pattern is simpler that the initial pattern p. it is erased.


Running this example in the Spec Explorer tool with the online algorithm showed a number of conformance discrepancies with respect to a TCP/IP-based implementation of this speci.cation written in C#.

the implementation does not respect the local consistency criterion and creates new threads for each message that is posted, without taking into account whether prior messages from the same sender have been delivered to the given receiver.


to ensure that the data inside the code block is accessed without interference from other threads.

programmers often assume that a synchronized code block will behave atomically.


3NF made our database more .exible by eliminating redundancy and inconsistent dependency.

it ensured that each table had a key, where the non-key attributes were dependent only on the key and no other attributes.


The main contribution of this paper relative to earlier work on Frenetic is the design of new algorithms for compiling these rich policies and for managing the controller-switch interactions that arise as compiled policies are executed in a network.

these algorithms handle NetCore s new policy language, and the core elementsof Frenetic s old policylanguageeven better.the NetCore compiler generates ef.cient switch classi.ers by (1) using wildcard rules that process more packets on switches instead of simple exact-match rules, and (2) generating rules proactively (i.e., in advance of when they are needed), again to process more packets on switches, instead of strictly reactively (i.e., on demand).


2.3 Grammar and state machine inference The StateChum tool extracts a .nite state machine from sets of positive and negative instances [19].

the user provides sets of words which are in (resp.


Gabriel s remark that I was the minimal necessary person needed to finish the task, taken in hindsight, offers an opportunity for a slightly different perspective.

the requirements for the successful completion of the task were, I think, broader than we might have been focusing on.


Specifically, since Ron was aware of the fact that there was a significant gap between his perception and that of the other team members with respect to the culture needed for the successful accomplishment of the software project, Ron adopted an approach that reduces the scope of change during the initial stages.

instead of starting the cultural change in parallel to the introduction of a new SDM, on which he would have had to decide himself, he started by preparing the human infrastructure needed for that change.


To extend the lower bound to the ID model, we give a series of local simulation results EC r PO r OI r ID, which state that a local algorithm for the maximal fractional matching problem in one model can be simulated fast in the model preceding it.

even though the models EC, PO, OI, and ID are generally very di.erent, we show that the models are roughly equally powerful for computing a maximal fractional matching.


While it appears that Agile Requirements are less efficient, in reality this time included requirements elicitation activities that were not needed in the other two conditions.

subjects in the US&OC condition had to talk to the Customer just to catch up with the other two groups in terms of knowledge.


We could apply the method-to-component approach of Figure 4 to the JAVA Core Re.ection design (rather than just the Bool interface).

we can produce a system of components for expressing re.ective computations just as we produced the Nand and Not components for Boolean expressions.


The extension of the type system is also reasonably straightforward.

the side condition of the Domain rule that prevents scope extrusion is easily implemented.


Currently, we are investigating the temporal locality of events.

when two or more consecutive events sent out by a publisher have overlapping attribute/value pairs.


Therefore, if the original length was l and the original energy cost was la (where ais a constant depending on the energy model), the new energy cost will be no larger than la + (2l)a .

the ratio between the new energy cost and the old is 1 + 2a .


We enhanced the original study by analysing an additional factor.

we examined the relationships between process conformance to TDD and the independent variables (i.e., quality and productivity) used in the original experiment.


As we can see, after a .rst unsuccessful replay attempt, without feedback, no scheme, except BB-2 for Apache, can reproduce these three bugs within 1000 tries.

without feedback, they are not much better than 1000 tries.


The rest of this paper is structured as follows: in the next section we will provide some background on the work done in this project.

we will discuss the company environment in which the project was performed, and the context of the still ongoing consulting project.


T ec eventually consistent, so it is split into T ec and T c ex 3 3 0 0 y. T ec ecutes instantly and uses versions x and does not use 3 1 x even though it is available to T3, because the snapshot of 1 0 tx, yu would not be internally consistent (see Condition 2).

t11 given a transition S0 ÝÑ S1, x belongs in S1 and 0 0 y and x are both in S0.


the properties are evaluated by actually applying optimizations and executing the optimized code.


The actual delivery of the system is a straightforward setting of parameters to instantiate a new email client.

we have developed an email client that allows us to add and remove features, and reconfigure the GUI, based on a set of XML specifications.


This was found to be especially true for commits in the Adaptive , New Functionality and Perfective categories, but not necessarily Re.ective .

these library dependencies rather are updated to adapt to a new environment, add new build/code features and optimize the build, rather than in response to restructuring or refactoring of the source code.


The lambda terms that we want to implement are built out of variables using application and lambda abstraction.

to store them, we use a recursive datatype term: term = VAR(D)|APP(term × term)|ABS(Fn(D × term)) we use data values to stand for variables.


The conditional mask f[x1.g1,...,xn.gn] describes a .eld f referencing a partially initialized object, which will become fully initialized when all .elds xi.gi are initialized.

the removal of the mask on f is conditioned on the removal of all masks on xi.gi.


2.3 Project Management Finally, we envision that the emerging design can be applied in a project management setting.

we are interested in Class MyWorkspaceRepositoryOtherWorkspaces Store Store OnlineStore    name:String address:Address address:URL   placeOrder(order:Order):void addItem(item:Item):void getQuantity(item:String):int scan(item:ID):boolean scan(item:ID):boolean     Green Red Red Green Green Red Green Green Yellow Green Red Figure 4.


Thus, when testing the soundness of LDP, we appeal to the concept of redundancy.

since LDP should be sound, its answers must agree with a sound decision procedure DP in a consistent manner.


When two threads complete the .rst phase, they are committed to the swap.

a break should not interrupt the second phase.


The observed throughput with the economic approach is usually at least as good as the default sizing policy, and sometimes slightly better.

the economic approach is as good as the default sizing policy even though it .xes the heap sizes at startup, and even with the limitations discussed in Section 6.


Minimal Interference: At the same time, data availability cannot be pursued over-aggressively.

since intermediate data is used immediately, there is high network contention for foreground tra.c of the intermediate data transferred to the next stage, e.g., by Shu.e in MapReduce [13].


The fundamental guarantee of the E V E N T WAV E model is that a logical node distributed over multiple physical nodes will maintain atomic event semantics.

a programmer can reason about the behavior of her program without considering elasticity: if a program is correct when running on a set of logical nodes, its semantics will be preserved even as the program scales up or down by running on various physical nodes.


3.1 Overview A control-.ow analysis computes a .nite map from all of the variables in a program to a conservative abstraction of the values that they can take on during the execution of the code.


6.1.3 Reliability Our Microdrivers implementation has only rudimentary code for detecting and recovering from faults in a u-driver.

we therefore restricted ourselvesto injectingfaultsthatwouldnotrequireafull.edgedfailure detectoror recovery module.we tested the ability of the system to tolerate failures that would normally causeakernel panicby injecting null pointer dereferencesin the user-mode portions of each driver.


These are made possible by taking advantage of the versioning capabilities of the SCM system to provide versioning of both the fine-grained units, and the larger aggregates assembled from those fine-grained units.

it enables a flexible mechanism for managing the his- tory of concern mapping within a system; for using data mining and machine learning mechanisms for concern identification; and even for providing stronger integration of compositional AOSD systems with other tools.


SCHEDULING FORK-JOIN REAL-TIME TASKS It was shown in [21] that there are unschedulable task sets where the total utilization of the taskset is slightly greater and very close to 1 even though there are m processing cores.

deadlines can be missed even though only 1 m of available cycles is used.


This paper discusses the design and implementation of Repo-Man, which is an implementation of the OMG CCM Repository Manager specification [6] tailored to enterprise DRE systems.

repoMan optimizes its CPU and I/O usage to provide fast/predictable access to component data for enterprise DRE sys-tems with a range of QoS requirements.


Item 2 implies that readonly int[][]and readonly (readonly int[])[]are equivalent.

a read-only array of int arrays is the same as a read-only array of read-only int arrays.


In this framework one can write the following de.nitions for the combinators Always and Eventually, and the formula to be monitored (M1): max Always(Term F)= F /.Always(F) min Eventually(Term F)= F V.Eventually(F) mon M1 = Always(x > 0 -Eventually(y > 0)) The Always operator is de.ned as having a maximal .x-point interpretation.

if by the end of the trace the property was not yet violated it is assumed to be validated and will evaluate to true.


In addition, code compactness might play a crucial role if the application requires rapid data processing (e.g., tracking a fast moving target, while predicting its trajectory).

the efficiency of the WSN might become compromised if the MAS language constructs are complex enough so that the virtual machine has to spend precious time processing interpreted code.


else if compare k k > 0 then mfind k l else mfind k r the programmer is left with specifying which value should be included in the map for every key.


As HdpH-RS retains backups of supervised closures, its performance is additionally predicated on a small retained closure footprint.

either the number of supervised closures is small, or the closures are small in size (on average).


Statistical techniques use data collected during execution of failing and successful runs to rank statements in the order of their likelihood of being faulty.

the Tarantula approach [9] uses a formula to rank program statements according to the intuition that the statements primarily executed by failing runs are more likely to be faulty than the statements primarily executed by successful runs.


By combining the results from the NULL and SCC conditions, there is the potential to eliminate over 71% of the snapshot barriers for all applications except mpegaudio.

with effective write barrier elimination, signi.cantly fewer write barriers would be needed if a snapshot barrier were used.


CONCLUSIONS Within a modern OSS 2.0 project ecosystem our results are substantially in contrast to earlier research conducted on individual projects when the state of Open Source software development had not yet evolved to its current state.

this work is novel because to the best of the authors knowledge it is the first study to consider these contributions in the context of an ecosystem.


In our setting, the local invariant we want to establish is what a dynamically generated type name means.

we will use possible worlds to assign relational interpretations to dynamically generated type names.


In this paper, we outline the application domain, give a brief overview of the DSL that we developed, and provide concrete data to demonstrate its effectiveness.

we show that the DSL has several signi.cant bene.ts over the original, XML-based approach including reduced code size, increased modularity and scalability, and detection and prevention of common defects.


All of these are just wrappers for simple names that tell us which lookup function to delegate to.

if acc is a VarAccess with name n, we delegate to p.lookupVariable(n).


Relationship between the points-out-of remembered set and the points-into summary sets.

it ensures that the nodes of any cyclic structures that become unreachable will be removed from the remembered set.


The source code analysis step and the runtime log parsing step, output of the process is the complete message templates, as Figure 3 illustrates.

we do not claim with a data structure containing each message s template to handle every situation correctly (despite extensive sup(regular expression), position in the source code, and the port for language idioms), but we do show that some of the names and data types of all variables appearing in the mes important features used in our results cannot be extracted sage.


The need for this invariant is because of the dif.culty of placing explicit barriers on accesses via untidy derived references.

an untidy reference can be created well before it is ever used.


Since is bigger, queries that are more satisfied are given a higher evaluation.

the more similar queries Pj completes, the larger evaluation Pi gives.


Together with Lemma 2.11, Theorem 2.16 immediatelygives an induction principle for data types of the form Te(µa.d[Tea/a]).

for effectful streams, the rigid-induction principle, together with the observation after Def.


Each of these correspond to a restriction and re.nement of cell.

contracts based on these are only substitutable for cell in certain architectural contexts, but, when substituted, they have reduced WCCT values; call these t1,t2 and t3 respectively and assume t1 <t2 < t3 = Tmax.


The proposed WSB was compared to FTL, BL, NFTL and FAST management strategies.

fTL and NFTL adopted a greedy policy for the garbage collection: blocks in the .ash memory are circularly scanned to .nd the victim block to reclaim, and a block is considered as a victim when the number of invalid pages is larger than the number of valid pages in the block.


.t abt(t1) .t1,v1.DSTM.rs ' (t1,v1) = DSTM.rs(t1,v1) .¬.t abt(t1) .t1,v1.DSTM.os ' (t1,v1) = DSTM.os(t1,v1) .¬.t abt(t1) def where .t = t1 = t..v1.DSTM.rs(t, v1).DSTM.os(t1,v1).

abt(t1) any thread t in the .nished state is allowed to validate its read set; in doing so, every owner of a location which t read becomes aborted.


The components are described as Java classes with methods corresponding to our notion of an interface.

the automaton for scheduling speci.cation can be described directly, but we also support a variety of alternative high-level speci.cations.


Therefore, for each activity Ai .MT (BP ), a set of m service candidates SAi = {si1, ..., sim} are assumed to be discovered in the solution space (Figure 3).

sAi includes binding links to di.erent services providing multiple implementations for activity Ai with varying QoS properties.


Command mitigate (e,e) c executes the command c while ensuring that timing leakage is bounded.

the expression e computes an initial prediction for the execution time of c. The label e bounds what information that can learned by observing the timing leakage c. no information at level e' such that e' g e can be learned from c s execution time.


Finally, the .ve accuracy values were averaged to obtain an overall accuracy value.

the evaluation of the models was performed on previously unseen executions.


The reason for this is that they assume static provisioning of VM instances.

they require that the VM instances are already provisioned and would not change over time.


An extensive survey of the constraint-handling techniques proposed in literature in the context of evolutionary algorithms is contained in a paper by Coello Coello [6].

several kinds of penalty functions are listed in the paper,together with an analysis of advantages/disadvantages for each of them.


In fact, the Model and the Sensitive message interfaces may contain the same methods but since the PCDs are dependent on view concepts, there is no confusion.

the calls from Config to Business will not be selected as join points for the purpose of authorization.


In this paper, we describe how this middleware can support a cross-layer adaptation of SOA systems.

we focus on the server-side perspective of SOA, and we show that our middleware is able to exploit both service interface and application layers technologies for supporting a coordinated adaptation of both layers.


OVERVIEW OF OUR APPROACH To optimize the stack data management, we propose to perform stack data management (i.e., transfer stack data between scratchpad and global memory) at the whole stack space granularity.

we keep on instantiating stack frames in the local memory until the management point.


This component performs standard machine independent optimizations and identi.es portions of data .ow graphs suitable as speci.cations for codelets.

loops (While or Until nodes) that are amenable to data parallel implementation are identi.ed and converted to use equivalent code structures with either a ForAllConstruct node if the result is an array, or a ForAllReduce node if the loop computes the result of applying an associative/commutative operator to the set of results of each loop cycle.


With this information, LFS can identify the locations of invalid data within a segment.

it examines the inode structure where physical block addresses of .le data are recorded.


While the syntax of the code is quite standrad, there are a few signi.cant limitations forced by the fact that this code is compiled into a boolean circuit.

recursion and pointers are not allowed and all loop bounds must be compile-time constants.


As a consequence, concrete patterns are rarely used in existing parser-based tools such as mainstream compilers.

the lack of concrete patterns is particularly limiting the implementation of convenient user extensions in tools such as extensible compilers, code inspectors, model checkers, etc.


The de.nition of an enf bisimulation is slightly different from the one in the original presentation [19].

the variant de.ned here is equivalent to what is called an enf bisimulation up to .


The kind of actors related a usecase We assume that the degree of work di.culty increases by related actors.

a complex work Table 1: The example of scores with actors  Table 2: The example of scores by multiplicity of actors Sta.


This paper presents ANEK, a tool and accompanying methodology for inferring speci.cations useful for modular typestate checking of programs.

these speci.cations consist of pre and postconditions along with aliasing annotations known as access permissions.


Note however that we work on a di.erent level of abstraction: we give types to components and check that the way we connect them is coherent.

we do not type-check the code of the components.


Unfortunately, despite introducing many important components, GHC RTS did not scale on multicores, leading to poor performance of many network applications that try to use lightweight Haskell threads.

our experiments demonstrate that even embarrassingly concurrent network servers are typically unable to make effective use of more than one or two cores using current GHC RTS.


While this may be true, we aim to create a new architecture where decisions do not always have to be made at the game server and the fastest route to a client is actually through a communication proxy located close to the client.

the shortest distance in our architecture is not through the game server but through the communication proxy.


Moreover, the restricted domain makes Rhodium amenable to rigorous static checking that would otherwise be infeasible.

the user provides a simple semantic meaning for each data.ow fact schema, which the Rhodium system uses to automat ically prove that the user-de.ned propagation and transformation rules are correct.


Every edge in the network has some nonnegative weight associated with it, and the distance between two nodes is the minimum, over all paths between the nodes, of the sum of the weights of the edges on the path.

the normal shortest-path distance with edge weights.


Third, as the last major hurdle, to ef.ciently support high-level queries, a Fay tracing platform must correctly integrate with new or existing query languages and data-parallel execution frameworks.

fay query-plan generation, optimizations, and task scheduling must correctly consider the difference between persistent, redundantly-stored trace event data and tracepoint-generated data which is available only at an online, ephemeral source, since a tracepoint s thread, process, or machine may halt at any time.


These relationships are the process of making the reusable asset "fit" into another development context.

recomposition is the process that allows a reusable asset to become an artful integration in addition to a system integration.


XCert achieves a strong correctness guarantee by proving the correctness of the execution engine fully formally, but it also provides excellent extensibility because new optimizations can be easily expressed in the DSL and then checked for correctness fully automatically.

while adding only a relatively small amount to CompCert s trusted computing base (TCB), our technique provides the following bene.t: additional optimizations that are added using PEC do not require any new manual proof effort, and do not add anything to the TCB.


Phase 1: Assumption A: There are no write operations to SWMR registers in all legal runs.

we assume for the moment that there is a wait free algorithm that uses only d MWMR and no SWMR registers.


MG, wemust havethat RJi = PIi .In the second case, assume that there is no assignment from the variables of sH to values in adom(Ii) so that the antecedent of sH becomes true.

there is no homomorphism from E2 to the binary relation EIi of Ii.


Di.erently from traditional software systems, where a combination of static and dynamic analysis can be used to detect design patterns [13], in the context of service oriented architectures pattern detection can only rely on observing SOAP messages, while the source code is not available.

in this context patterns are identi.ed by a sequence of service interactions, while the system structure is not visible and, above all, dynamically changing.


Suppose a frame bound F,a stack bound S, and a heap bound M have been inferred for method M. If the initial con.guration C0 = ((p, F, 2) : .,., ret(E), s-F, h)satis.es the following conditions: (1) p F h =M (2) p F s =S, then the stack space s and the heap space h are adequate for the execution of the program.


This extension satis.es the following property that is crucial to algebraic fusion: rev [-] = id rev (k ·k.)

= rev k .rev k. rev is a monoid homomorphism from the monoid of list contexts to the function space monoid (Tlist .


4.2.3 Bene.ts The application of the Dublo pattern is reasonable, if the following bene.ts provided by this pattern are of relevance: Smooth migration: incremental replacement of old business logic and client software by new middle-tier business logic.

if the migration cannot be performed in a short time interval, this issue becomes essential.


A node d dominates a node n if all the paths that reach n from a designated start node go through d. Speci.cally, we observe that if two nodes have the same dominator in the constraint graph, then their points-to information would be equal.


$10.00 to the notion of an aspect-oriented language module .

a module that implements (pointcut-and-advice .avoured) aspect-oriented features, and is applicable to a wide range of base languages.


The intangibility of software refers to the primitive property of software and its development.

all software development processes and their work products, such as problem description, requirements specification, design, and implementation, are intangible in the cyberspace.


If two features introduce (or re.ne) the same class or introduce the same method, then a piece of glue code may be needed to coordinate the collaboration of the program elements introduced by the different features.

such introductions may result in internal feature interactions.


Implementation of Match and Merge involves answering several questions.

what criteria should we use for identifying correspondences between different models?


Both the algorithms can be tuned using a parameter a that controls the balancing of the number of executors assigned per slot.

a a.ects the maximum number M of executors that can be placed in a single slot.


In most of the cases, this is the intended behavior.

none of our benchmarks catches this kind of exception.


INTRODUCTION Architectures of modern Digital Signal Processors (DSP) [7, 10] and multi-media extensions [19, 8] aim to combine high performance execution with low power consumption.

they exploit the natural parallelism present in signal processing applications by simultaneously executing the same instruction on multiple data elements.


This result matches with the .ndings in [9].

with the increasing of the size of the input data set, the percentage of shared data among tasks decreases and the e.ectiveness of CATS degrades in consequence.


To deliver good performance in WAN environments, the MobiDesk display virtualization architecture couples its virtual video device driver approach with other latency sensitive display mechanisms.

client display hardware resources are exported to the server and leveraged to reduce the latency of display processing.


which case taking power-gating control in that branch when the other branch is instead taken may not reduce the power requirements.

the path lengths of the taken and not-taken paths of a branch may not be equal and therefore one path may satisfy the cost model and the other path may not.