Except for the contiguous allocation, the other two would scatter the cached object all over the UNIFIED file, and then decelerate the object access.

we decide to use the contiguous allocation in our method From Section 2, we know that the multi-R/W scheme used in Squid is beneficial for the machines equipped with less memory, but it degrades the proxy performance due to many system calls.


The data in Cloud systems are organized in the form of keyvalue pairs.

current Cloud systems can only support keyword search.


The Function Repository in the described form contains all necessary information to con.gure the API s of standard software modules.

the combination of standard software modules represents the basis for an ef.cient reuse of the application as already explained in Sect.


Since the completion code is not found in a single location, it tends to result in variability implementation spread across the product line architecture.

it can lead to a negative impact on the activities of localizing and understanding the con.guration knowledge speci.cation.


It is hard to develop a formula that defines the optimum number of employees that should attend on each decision making context, but what is certain is that the communication and human interaction skills are becoming more and more needed in a software engineer s work.

there is clearly a visible shift from relying the messenger archetype towards active participation in the world of software product development.


Existing approaches do not support modelling the network properties of cloud infrastructures.

a holistic approach that models both the computing as well as the networking infrastructure should be applied [16, 17].


It is highly possible that in the near future we will witness a paradigm shift from a battery-based to an ultra-capacitor-based design for all kinds of embedded devices.

it is essential to explore this frontier in advance.


We did not make such a .ner distinction between sparks in the current implementation.

we have not yet pro.ted from the advantages of this design.


These locks con.ict whenever a pair of methods do not commute.

the locks prevent non-commutative operations of distinct transactions from executing concurrently since one transaction will be delayed.


As the algorithm descends into the loop body, x is bound to an adaptive value at choice c, and the CHOICE rule marks x as being in.uenced by that choice (I is extended to re.ect this).

next, we descend into the if statement and apply the IF rule, causing A to be extended to include c since that choice in.uences the guard expression x. when we reach the following assignment statement that increments i, the A set contains the choice c as an in.uence, which makes the new de.nition of i adaptive (in.uenced by c).


Although most current SCADA software systems were developed using component technologies, owning to a lack of generally accepted interfaces, those components were designed and developed by a single company for a speci.c system or speci.c domain.

they cannot be applied to systems manufactured by other companies.


A simple program such as notepad.exe loads more than 30 DLL .les.

a more e.ective visualization is needed.


Example actions from the BLink tree interference environment.

the assertion that the key-value pair (k,v) is contained inthe BLink tree is stable.


Among them, maybe the most important is that of the familiarization difficulties that older people encounter when they try to use state-of-the-art hardware and software solutions.

the acceptance ratio of such approaches remains till now at low level.


The relationship between quality attributes and runtime environments is complex, fuzzy, and hardly described precisely.

it is an effective method to achieve continuous quality optimization by using the control theory based on runtime feedbacks.


To save extra space, we apply the technique described below that typically reduces the size of a stub from several hundredcharactersto under50.Akey insightisthatJavaScriptisa dynamic language that allows function introduction at runtime; we do not have to transfer complete stubs over the network as long as we can generate them on the client.

we parameterize the text of each stub with its name and argument names and then introduce a helper function exp(function_name, argument_names) to generate the stub body at runtime.


Web applications are becoming the dominant way to provide access to on-line services, but, at the same time, there is a large variance among the technical sophistication and knowledge of web developers.

there will always be web applications vulnerable to XSS.


Jan Botchers: HCI is much closer to architecture than to software engineering.

we should largely adapt Alexander's notion of patterns, and change it consciously for HCL Just using patterns as a format for expert commu- nication, as it is done in current software engineering pat- tern practice, ignores their potential.


Unlike other control connectors, a Loop connector never returns control via its port; rather, after receiving control, it repeatedly passes control to its only connected port.

a Loop can only be used at the top-level of a system that runs perpetually.


Unlike the earlier algorithm, our algorithm works directly on points in Euclidean space without embeddings.

it has the following advantages over the previous algorithm: p( For the l2norm, its query time is O(dn)logn), where p()1/for E(1,10](the inequality is strict, see Figure 1(b)).


All the reviewers of this study are researchers in the software reuse .eld, focused on the aspect-oriented programming, software testing and software product line, and none of the techniques and tools developed by us.

we are not aware of any bias we may have introduced during the analyses.


When given an argument xss of type list(list(T,I2),I1), the function concat returns a pair (pf , res) such that pf is a proof value of prop MUL(I1,I2,I3) for some integer I3 and res is a list of type list(T,I3).

pf acts as a witness to certify that the length of res is I1 * I2.


This variable is an array, and its values are taken from the cnt variables in each module.

cnts[j] is value of cnt from the jth node module.


For example, take the assumption assume(MethodDoesNotModify, Any Field, C::f()) This assumption forces IOpt to assume that the analysis success for any .eld and C::f().

all of the property invocations property (MethodDoesNotModify, T::x, C::f ()) property (MethodDoesNotModify, G::y, C::f ()) ... property(MethodDoesNotModify,subtypesObject::x, C::f()) will succeed.


However, this is unlikely to give much bene.t and will signi.cantly complicate the context-switch in the operating system.

for each taskit is su.cient to traverse all blocks of its code, and add to its context all registers which are live in that blockand can be destroyed by any taskthat can preempt it (i.e.


Moreover,pinpointingtasks onprocessors avoids migration overhead.

the Ocean execution is up to 30% faster and the differenceis increasing with the number ofprocessors.


Additionally, since the proposed approach also relies on the SVM algorithm, the tweaking would produce better results for both pure machine learning approach and the new proposed approach.

the extra preparation e.ort would not change the conclusions of the experiment and, thus, was unnecessary.


Using usage statistics measured in outside of the VM, it is di.cult to determine what amount of a CPU resource is actually required.

simply, we pick up the VM that is probably in a race-to-halt Figure 4: Experiment environment state.


As mentioned above, context transition rules help validation of some properties that the contexts should satisfy.

applying automated checking methods (such as model checking) to the program written in EventCJ will also be an important direction of our research.


Our solution allows Web applications to delegate access control to users preferred authorization managers.

these users can protect their online resources with their preferred access control mechanisms.


Each file specification is optimized to manage a specific data type efficiently.

each file specification has evolved with slightly different notions and implementation technologies.


Moreover, services appear (and disappear) in the grid with no central coordination.

to .nd out the most suitable service to ful.ll their needs, grid users must resort to Grid Information Services (GISs).


From the subject reduction theorem, we know that a(E ' [fork e]) A.From Lemma 1, we know that  ' '' a(E [fork e]) = a(fork e); a(E [0]) = A; a(E [0]).

we must have a(E ' [0]) L. Therefore P2 .Li and we have a contradiction.


4, A /= .P (MP ), and hence A /= MP , which is a con core core tradiction to the fact that A = MP .


By applying this result twice, we can conclude that the Datalog program pM is bounded, because there is a .nite subset of conjunctive queries in the in.nite union such that every conjunctive query in the in.nite union is contained in some member of this .nite subset.


On the other hand, with BeneFactor, after Grace changes references of event to intEvent, BeneFactor detects that she is renaming a local variable.

it places a quick .x refactoring option on the problem markers at the lines where Grace did name changes, as illustratedin Figure1, suggesting that she allowBene-Factor to .nish this rename refactoring automatically.


In a conversation involving multiple parties, only those agents who have been formally recognised and registered in the Yellow Pages after their starting up will be regarded trustworthy and Yellow Pages Agents are responsible for acknowledging the trusted parties in the network.

they play the role of Certificate Authority (CA) in the sense that they assure the trustworthiness of communicating parties.


each container must be given a symbolic name unique in its host, as it is not possible to have two Erlang nodes with the same name running in the same host (Erlang nodes can be given short-or full-names.


This means that every instance that has not been initialized must be checked to .nd out whether the class of that instance is Controller or not.

a developer must also test the parts of the code that fall into category #4.


Applying the technique once means building the PCG using the algorithm of Section 3, and sharpening data-.ow abstractions using the algorithm of Section 4.

the SR phase aims to unfetter a maximal set of opportunities in opts on srefs.16 6.1.2 Enabled and Baseline Executables Just prior to the SR phase, opts on srefs is repeatedly applied until the IR reaches quiescence.


In our case, this process is performed by a combination of the QuickCheck tool execution itself, according to the previous work.ow, and an adapter that invokes the real SUT transforming the speci.c values that QuickCheck generates using the data generators into a data format that the real SUT understands, also transforming the SUT return values into QuickCheck format again for test evaluation.

quickCheck not only automatically generates a large amount of speci.c test cases with randomized input values from the properties.


Unfortunately, distinguishing between the token types identifier, reference and keyword is not as easy since they are valid in accordance to the same regular expression.

user interaction is required to determine the token type in those ambiguous cases.


By doing this, the implementation of the new features and the original version get mixed.

the extended compiler evolves into an independent system that has to be maintained separately.


This is because, wait-free eliminates task blockings .

the algorithm produces a critical time (or deadline)-ordered schedule, which is optimal for under-load situations (i.e., all critical times are satis.ed).


Without returning from a function, a nested function can manipulate its caller s local variables (or local variables of its indirect callers) by indirectly calling a nested function of its (indirect) caller.

many high-level services with stack walk (such as check-pointing and copying GC) can be easily and elegantly implemented by using LW-SC as an intermediate language.


The following lemmas demonstrate that all set constraints imposed by TCare of the form Ivp.

the least soluction of these constraints de.ne a system of lower bounds on the size of each p. LEMMA 4.9.


Unlike ContextJ, the with-block in NextEJ can specify the instances that are a.ected by the object adaptation within a speci.c control .ow.

unlike EventCJ, NextEJ cannot control object adaptation asynchronously triggered by events.


Therefore, there are BPs hidden in the LIS that are not defined in the original set of BPs.

the recovery of hidden BPs from the LIS by means of the ADM process is necessary to obtain the current BPs.


Instead, a con.ict debugging technique should be used to prove unrealizability and point the engineer to con.icts in her speci.cation.

the correct-by-construction implementation does not eliminate the need for debugging: it lifts debugging from the concrete implementation to the higherlevel, declarative speci.cation.


We distinguish between such simple, short actions (instantaneous in the particular sense that they are completed within the execution of a step of the automaton) and long actions (asynchronous), as can be done classically with synchronous models [3].

when the automaton receives ml, it emits la and goes to S2 representing the processing of the action la.


For example, types are often obvious in local and helper declarations.

type annotations are always optional in Star.


In addition, the advice activity must possibly be executed several times.

in the advice body, end is substituted with 2 Note that new participants introduced by aspects are initialized with local types def x = end in x, so that the local weaving of projected advice is always de.ned.


Open source projects (for example, Linux, Firefox, and Jikes RVM) all have a core group which exerts this centralized control, even as they accept work from a wide range of contributors.

simply having a bazaar [11] is untenable we at least need a small church next to it.


The programmer needs to understand the full aspect system in order to understand their code, and there is no direct way of iden- tifying all of the aspects being composed except by looking at the build process.

in compositional systems, the final executable structure of the program does not precisely match the structure expected from reading the source code of any standard semantic unit of the pro- gram.


Considering that initially scheduler would conduct scheduling as aggressive as possible, node b1 is considered to have higher potential to be re-scheduled thus have higher chance to reduce spills via re-scheduling.

node b1 is given higher priority to be marked for register allocation.


In addition, CoBaSA was designed before we had access to any of the Boeing models, and as will be apparent in later sections, there is nothing in CoBaSA that is specialized to the avionics domain.

we expect CoBaSA to be widely applicable, e.g., during our work with Boeing, CoBaSA was able to easily handle what Boeing described as serious architecture changes.


In general, the more speculative the trace prediction scheme, the larger we need to size the fragment cache, to compensate for the larger number of traces picked as a result.

the interpretive overhead has a ripple effect throughout the rest of the Dynamo system.


The main reasons for this similarity across threads are: (1) programmers tend to write one piece of code and increase the number of threads that execute the same code (2) programmers tend to do static load balancing between threads to utilize all cores.

though we might not be able to predict how long each thread will execute, we can easily predict which thread within a thread group (explained in section 3.2) is lagging behind, because all threads in the same group tend to have similar execution lengths.


Sun.ow, Lusearch and Tomcat are among the most scalable benchmarks.

we focus on these three benchmarks for our tests.


On the other hand, Easynet, which does not offer different transfer rates for in-network traf.c, exhibits negligible performance differences for connections with different AS-path lengths.

performance from Onorecommended peers will not be signi.cantly different than those picked at random.


and Nagappan and Ball use the overall number of alerts or the alert density to identify potential fault-prone modules, while we focus on fault-prone files.

we also investigated whether there was a correlation between the number ASA alerts and field failures at the file level to better compare our technique to theirs.


These instances are only started if an user bid is higher than their current price.

with Spot instances, the host availability depends both on the user s bids and the instance price market variation.


Such defects are often triggered by unexpected interleavingsofeventsinthe realworld.

run-time debugging tools are required to detect and diagnose these defects in the post-deployment phase.


(S2|S3,S1), (S2,S3|S1), (S2|S3|S1), (S2,S3,S1), where | represents a fusion partition or, in other words, it implies that statements on either side belong to different loop nests.

a total of 24 different fusion partitionings are possible for only 3 statements considered.


3.3.2 Server-side Software The aim of the EPCFind backend is mainly to act as an information server, storing the events reported by the mobile software (Report and AutoReport MIDlet) and providing an interface for queries (Find MIDlet).

the EPCFind backend complies with the EPCIS standard.


= s2 and d(s1, s1) = 0) distance function that also complies with the triangle inequality property (d(s1, s3) = d(s1, s2)+d(s2, s3)), for any si .

s. d() is called a metric distance function.


Thus F distribution of watermarked points may be destroyed.

the method is not robust enough against massive crop .


Also, for a new result that is a superset of a previously encountered result, the set of real and noise values for that new result will also be a superset of the real and noise values from the previously encountered result.


Background services on mobile phones continuously run, even when the device is in stand-by mode.

it is important that the service does not consume too much CPU power as other apps may be affected and battery will be drained.


For tasks in this example, slack reclamation algorithms are unable to reclaim slack at the completion of the second taskinstance of task t1, since there is no task instance which is ready to reclaim it.

in order to reduce the energy consumed by task execution more effectively, the information of the execution patterns of multiframe tasksshouldbetakenintoconsideration carefully.


For example, in SML: let val l = List.rev [] in 42::l end The type of l depends on the next line; until then it is of polymorphic list type.

a programmer can t determine the type of l by reading only its binding.


{0, 1}can model each node s ability to sense whether it is in or out of a region over time (e.g., at time t .T anode v .V for which sA(v, t)=1 and sB (v, t) = 0 is inside region A and outside region B).

although the monitored regions are dynamic, with changes monitored by nodes sensors, we assume the sensors nodes themselves are immobile.


The VM image provided by Nimbus that con.gures the Globus Container assumes that the Container will be unique in the deployment.

it provides its own Certi.cate Authority (CA) to self-sign a host certi.cate.


For handling large datasets, the available address space of a 32-bit framework, however, would be too restrictive which is why we took the algorithm module of Viracocha, compiled it as a 64-bit library version, and invoked the parallelized critical point computation from within a test suite.

the MPI layer of Viracocha was not available so that only OpenMP could be considered.


complex use cases (weight15): eight or more transactions.

both UCP and iUCP rely on this generic formula to calculate the estimated effort (EE), in hours: EE=UCP *PF Where PF is the Productivity Factor (the number of hours an organization needs to implement one use case point) and the UCP is the number of points.


We obtain very similar results using the same experiment with a .xed-size nursery collector which, as we show, takes the slow path more frequently.

we believe these results will hold across different collectors and compilers.


Intuitively, it calculates the likelihood that the evaluation biases observed from incorrect runs were generated as if from f(X|Correct).

a small likelihood suggests that evaluations of this predicate in incorrect runs are signi.cantly di.erent from that in correct runs.


The Validation Component .rst again matches the feature BBIE.

it needs to be ensured whether the performed update is valid.


Moreover, as we shall show, nominal abstract syntax can be implemented directly in Haskell using type classes, and the de.nitions of nameplate functions such as captureavoiding substitution and free variables can be generated automatically for user-de.ned types.

nominal abstract syntax and generic programming techniques can be fruitfully combined to provide much of the convenience of higher-order abstract syntax without sacri.cing the expressiveness of .rst-order abstract syntax and without any language extensions beyond those needed already for generic programming in Haskell.


As outlined in the following, it is much more ef.cient to choose the architectural level to determine the relevant events than the operating system or hardware level.

we propose in this paper to exploit the high-level abstractions available at the architectural model to achieve the deterministic replay for hard real-time systems with only minimal run-time overhead and without the need for additional hardware.


The above example elaborated on one such case.

applications need to be able to control their own pumping for a particular STA and for this they would need to control clean-up of RCWs.


Given the fact that JML guarantees a side-effect-free specification, one can call (or write) only the side-effect-free methods within JML specifications.

jML provides a pure keyword that can be used to declare a method as a sideeffect-free method.


Since LALR(1) parser tables have all isocores merged fully, they contain all such inadequacies.


Each time a match is found, Proton++ executes the callback associated with the gesture expression and .ushes the stream.

with a single stream, Proton++ is limited to recognizing at most one gesture at a time.


For reasons that will become clear later, the control is required to participate in a pass event together with a drink event.

the annotation pass:1 at the reference from class Control to class Slot requires aslottoparticipatetoo.


Both of the implementations transfer the same amount of intercommunication data because a task context is stored into a contiguous memory area.

for the memory-saving oriented implementation, we can estimate that the execution time needed to acquire a running task is 12.5ms and 180 bytes of data are required to be transferred.


7 Acknowledgements It is dif.cult to obtain color volumetric data, other than the Visible Human Dataset [Banvard 2002].

we are grateful to Taiki Kinoshita, Kenichi Kudoh, and Junichi Sugiyama for capturing the color chocolate crisp data.


Because the underlying production system paradigm does not specify an explicit flow of control, it is rather difficult to grasp the structure of this kind of user models.

we developed an algorithm that analyzes the interdependencies of ACT-R/PM productions by resembling the main parts of the matching process of the production cycle.


The weight of a path depends on its length and the contained block types.

the block types shall be weighted such that those paths containing root causes get a higher weight than the remaining ones.


Instead of explicitly reasoning about divergence or strictness in the re.nement logic, which leads to signi.cant theoretical and practical problems, as discussed in §8, we choose to reason implicitly about divergence within the type system.

the second critical step in our path to .D is the strati.cation of types into those inhabited by potentially diverging terms, terms that only reduce to values, and terms which reduce to .nite values.


While on some architectures it is worthwhile to perform .ne-grained code cache evictions [19], this result does not hold for embedded architectures where memory is one of the most critical resources.

we implement a simple, yet ef.cient .ush-on-full policy in Pin for ARM.


If this action were to fail, then a landing would not be possible.


However, System z machines typically have many processors.

we provide an option in the Event Flow view, to explicitly show event flows across multiple processors.


Comparing to other interpreters, we note that TR-LINK outperforms SUB on the geometric mean of the benchmarks by about 6%, and SableVM 1.1.8 by about 4%.

tR-LINK more than makes up for the pro.ling overhead required to identify and generate traces.


If there exists an inter-iteration dependence between u and v, then the execution of statement v initeration i+ w(u,v) reads the resultsgeneratedby u in iterationi.

the earliestiterationin which v canbe executedis w(u, v) iterationslater than theiterationin which u is executed.


B or A" B. Applicability with coercion is used only to determine coercion at compile time.

it is always based on the static types of the arguments and receiver.


2.1 GenArch Extensible Infrastructure In order to enable variability management and automatic product derivation of complex SPL architectures, such as MAS-PLs, we considered necessary to extend the GenArch infrastructure [2].

we develop a new extensible infrastructure whose purpose is to allow SPL engineers customize the tool through the addition of new DSAMs.


Most execution time is dominated by a handful of the 107 phase instances.

the measurement in Figure 3 comes mostly from large phase instances.


All the semi-join attribute values appear in R with frequencies less than NB reducers: Following the same demonstration method used for the mappers, we divide R into NB reducers relations: R1,R2,...,RNB reducers such that the frequency of each semijoin value v is exactly equal to 1.

the receiving and local histograms records merging costs on each reducer re lated to each partition Ri is at most: NB mappers ` ´ i i *|GHist(Ri)|* mp + ||GHist(Ri)|| * (t+ t) , r h NB reducers NB mappers ` ´ « i i *|Ri|* mp + ||Ri|| * (t+ t) .


Moreover, after an APCC is analyzed, the result can be used for later allocations without re-analysis.

the overhead is amortized by all the allocations from the same APCC.


Based on the idea for the compiler generators such as YACC/BISON, we developed an automatic tool called ICER which allows software engineers in a pro.le to de.ne the syntax of their application models.

a model compiler is automatically produced and it can .nd any error which violates the syntax .


The guarded-command notation for describing concurrent systems has been popu- where write~(j) (readi(j)) is the write (read) corresponding larized by many researchers including Chandy and Misra in to storei(j) (loadi(j)).

from these three rules we get their Unity programming language [9].


JUnit is a standard popular unit testing tool for Java applications, but there is no such tool for system testing.

an organization must duplicate their investment of time and effort to maintain different types of testing tools and training their engineers.


As interrupts happen non-deterministically, a single simulation run might not catch the worst case of interrupt function invocations.

we added a safety margin of 20 bytes to each stack and so far no stack over.ows occurred during our measurements, which of course is also monitored by the plugin.


With each memory location a taint bit is associated, which indicates whether that memory location is data dependent on an input.

the taint bit has to be manipulated for every memory instruction.


When a cold counter is maintained, it should be incremented on a poisoned path rather than the counter indicated by the path register.

logically, the instrumentation at the end of a path looks like: if r < 0 // if path register poisoned cold_counter++ else count[r]++ This potential branching at the end of each acyclic path can increase the runtime penalty of the instrumentation code.


Component composition is an iterative process where we define new and increasingly complex component compositions in a recursive and hierarchical fashion.

component-based applications represent groups of interconnected component plug-ins in a composite architecture.


They would either have been charged higher fares or they would have seen fewer flight options.

an unexpected finding from the investigation was that three out of eight prominent global air ticketing services had failed to perform basic software testing and had failed to perform usability testing with older adults or novice users.


Code was refactored as deemed necessary by the pairs, but unit tests were ignored.

there was nothing to check and balance the refactoring between different pairs and individuals, with code changes ping-ponging back and forth.


For the case thatEmax is large enough, the if-statement in Step 11 is always true.

energy consumption ej * =3 is assigned to the .rst four frames j =1,2,3,4 in Step 19.


Although this representation looks more intuitive, it can be very di.cult to correctly and directly represent a property into a B¨uchi automaton.

in order to overcome this problem and to provide PSC with a formal semantics, we propose an algorithm, called Psc2Ba to translate PSC speci.cations into B¨uchi automata.


For example, if we see the statement x = p2 - p1; , we know that the C language requires that p2 and p1 point to the same bu.er and thus share the same length.

we unify the lengths of the pair after this program point.


If two features are in never relation, then there is no valid product containing both of these features.

any reference between these two features inevitably leads to a type error (if the features are not dead).


All of the instances of the dependability aspects did not need to have any particular association with classes, objects or control flow.

they have been implemented with the default issingleton()association.


We enforce this by allocating a fresh location l ' initialized with the contents of l, and then binding l to err to forbid access through l. The remainder of our semantics (not shown) is strict in err, and any computation that goes wrong reduces to err (rather than becoming stuck).

any program that tries to read or write l within e2 will reduce to err.


In most situations, one has to set a time limit on symbolic execution.

it is important to guide symbolic execution to select pro.table states to explore during its search.


For example, in Figure 2, if the receiver interacted with another cyber component that processed the messages, then during synthesis, it would be possible to modify the receiver component as well as the component that processed these messages.

we impose no restrictions over CC interactions.


If the adversary is strong, its best strategyis to schedule p s SCAN before q s second UPDATE if q s coin .ip returns 1 and after if it returns -1.

under the best strategy for a strong adversary, the expected value of the sum in p s SCAN is (6-8)/2 = -1.


Analogously to the ConceptDefn-Scope .ag, ConceptClang adds the ConceptMapScope .ag to indicate that one is parsing a concept map declaration.

the following .ags are set on the scope of a concept map: ConceptMap-Scope, DeclScope, and RestrictedScope.


In the ML library, a modi.able carries references to a value, a write operation, and a list of edges.

modi.ables form the nodes in the dependency graph.


the subtree rooted at that element, in the case of a tree.

when updating the maximum value in an interval tree, the update is only propagated towards the root.


Besides, as we handle components and aspects with the same formalisms, it is also possible to develop aspects incrementally as if they were components themselves.

for example, it is very easy to evolve from CSMA to CSMA/CD synchronization by developing the aspect that encapsulates the synchronization concern; on the contrary, doing so over the original components would be unfeasible, because it implies complex modi.cations in every component, requiring a deep understanding of what they do (de.cient separation of concerns).


Here the communication from the commercial mobile device to the first 6LoWPAN node can be achieved over Bluetooth.

locawe supports now data gathering directly from wireless sensors to mobile devices.


Indeed, we agree with the developers of VMKit who believe that using OSR would enable them to speculate and develop runtime optimizations that can improve the performance of their VMs5.

given the value of and need for OSR and the wide-spread adoption of LLVM in both industry and academia, our paper aims to .ll this important void and provide an approach and modular implementation of OSR for LLVM.


5.1 Representation As we explained in [14] and outlined in Section 2, performance of sorting depends on the number of keys N and the entropy of each digit Ei.

the condition bit string has to encode the different values of these two input characteristics.


Due to this variation, project managers cannot consistently apply project size estimation techniques such as function or feature point analyses.

activity based estimation is usually performed for research and R&D based projects.


As stated earlier, for Windows, a GPS time-stamping driver has been implemented for providing synchronization.

the most difficult part for Windows already exists.


Only 32% of the blocks that are written in the migration were written in history.

simply counting the write accesses in history will poorly predict the write accesses in migration.


The header of physical layer frame consists of preamble sequence, Start Frame Delimiter (SF D) and Frame Length (F L).

receivers can distinguish frames of primary user from those of secondary user transmission by data rate and frame length.


By assump ii jj tion T .m s implementation and the implementation of S.m P S.m satisfy their speci.cations.

since Pi T .m (= j ) QT .m holds in the pre-state of the call, S.m establishes i (= QS.m j ) in the post-state.


Language Coordinates Dimensions Layout ANI M A LSCR I P T, ANI M A LSCR I P T 2 absolute, relative to a location 2.5 by hand DsCats n/a 2 automatic JAWAA absolute 2 by hand Matrix ASCII n/a 2 automatic SALSA n/a 2 automatic Samba absolute 2.5 n/a SVG absolute, relative 2 n/a ANI M A L SC RI P Ts support depth to control how overlapping objectsare drawn on the screen.

samba supports a similar feature by allowing objects to be moved backward and forward from the viewer.the dimension is 2.5 in the evaluation of these two languages.


we obtain 2(d(e)(S1, P 2)- d)· (d(m)- d)?


If included, all thread boundaries within the callee are ignored at run time; the hardware creates the illusion that the compiler had chosen Eb = Ø for the CFG of the callee.

inclusion prevents thread boundaries within function calls from interrupting the calling thread, allowing the calling thread to contain more basic blocks at run time.


4.2 KMA: A two-layer memory allocator We designed our allocator to address two main objectives: support generic, fully-.exible memory allocation and provide ready-to-use management of dynamic data structures (see Section 3).

kMA has two layers: a low-level traditional memory allocator and a high-level, customized layer 4 These are the SDKs we have used in this work.


5.3.3 Observations on Work.ow, Success, and Effort The participant s work.ow was substantially di.erent than that of the Case Study 1 participant, because he intended to formulate a speci.c action plan for enacting a change to the system.

he spent a considerable amount of time attempting to understand how existing code functioned, rather than simply tracing dependency connections.


For the conception of the prototype, we had access to mood metadata for 3795 songs.

theco-occurrencebetween genre and mood metadatais about 29percent in the cache database.


As in [28], the power consumption during this transition period is the same as that in the power-on state.

the total link energy consumption Elink can be estimated using the expression: PN Elink =(Pon ·Toni +Poff ·Toffi +ni·EP ), where Toni and i=1Toffi are, respectively, the lengths of total power-on and power-off time periods for link i, ni is the number of times link i has been reactivated, and N is the total number of links in the mesh network.


As a result, a process where the new fraction is installed, can start the election right away without waiting for other processes to .nish the adaptation.

the time for which the application is blocked or the service interruption time is reduced.


statements of trust are security assumptions of the users expressing trust.


We take a sophisticated approach to distribute the data tuple lookup process into individual database partition level.

data migration operations are totally transparent to distributed transaction processing and coordination.


ai captures the degradation of utility that occurs due to dropping of processes.

if a soft process Pi is dropped, then k = 2 µ= 5 ms P1 30 ms Figure 3.


The static allocation technique may lead to under utilization of the SPM.

we present a pro.le based approach which on the basis of live ranges of both variables and code segments, replenishes the contents of the SPM.


In this case, the procedure also needs to carry along the element-condition n1 = a.

it adds the tuple (n1) to T J ,but this time the local condition consists of the conjunction of (n1 = a) with (n1 = n2).


According to Santos [19], although declarative languages like NCL become the creation of some interactive applications easier, when an application becomes more complex the hypermedia document that describes it grows.

the NCL shall have many lines of code, which increases the probability of error, since the author tends to reuse settings by copying code.


In most tile sets these tiles assembly prior to the interior tiles.

propagation of an error within the interior tiles will be blocked by the border tiles and prevented from reaching an edge of the assembly.Intheproposed model,bordertilesin the tile set may only assembleif an interior tile next to the border is assembled.


However, those architecturally-relevant concerns are often realized by multiple module elements in the source code.

it is not trivial to associate anti-degradation rules with the group of counterpart elements realizing architectural concerns in the source code.


The non-aggregation curve is .at because in the experiment all NIC-level messages are 256 bytes independent of the total payload for the higher-level strided operation (shown on the x-axis).

we observe a constant bandwidth equal to the .ood bandwidth for 256-byte messages.


For now, it suf.ces to know that the signature of function check alone guarantees correctness of the types of the instance objects passed as parameters.4 Thegenerationstep usesre.ectiontoproduceajob equivalent tothe one createdinthe original mainprogram, and also performs atype checkinternally.

in a realprogram, one could omit the two checks above and the four long lines with generic type declarations, and instead pass the objects directly to function configureTypeSafeJob.


First, due to the sheer number of parameters of the underlying optimization problem, each of these heuristics makes different assumptions on the topology of the task graph and the data center respectively.

their performance can vary signi.cantly in practice and there is no single heuristic that performs best in all situations (Braun [1999], Munir [2008]).


Macros inlined after renaming However, the intention of the programmer is likely different: if he did not want the macro calls in the code, he would not have put them there in the .rst place.

if possible, it is better to change the macro substitution arguments and the macro de.nition to .t the changes in the syntactical structure, as seen in Listing 39.


Doctoral Symposium of the European Conference on Software Architecture 2010 Eila Ovaska VTT Technical Research Centre of Finland, Kaitoväylä 1 90570, Oulu, Finland Telephone: +358 20 722 111 eila.ovaska@vtt.fi ABSTRACT The goal of the Doctoral Symposium is to provide PhD students working in the area of software architecture the opportunity to present their research and to receive immediate and expert feedback for the successful completion of their dissertation research.

the ECSA 2010 Doctoral Symposium enables participants to sustain and discuss their ideas, methods, and preliminary results with senior researchers of the software architecture community in a constructive, friendly, and professional context.


Actually, GRE are a little faster in most circumstances, but the difference can hardly have big impact on testing, as it is not comparable to the typical time of executing test cases.

the time efficiency of these four algorithms can be summarized as tGA >> tILP tGRE > tH.


The main challenge is that the different products and product lines follow different business models.

the structuring and especially the prioritization of requirements for multiple products from multiple product lines are not trivial.


For performance, we constrain the total number of bins to a user-provided constant.

as inputs are generated the algorithm merges bins as necessary.


A reliability-driven instruction scheduleron the other side would not only balance the spatial and temporalvulnerabilities, but also account for crucial instructions to improve the software reliability, though it may incur a performance loss.

given a user-provided performance overhead, a reliability-driven instruction scheduler needs to optimize the software reliability which is a complex function of spatial and temporalvulnerabilities of different instructions w.r.t.


The analysis units in this study are the different business processes models retrieved from an information system.

the study consists of applying all the refactoring operators in different orders and obtaining business processes that are in turn analyzed to answer RQ1.


per key)  a result, we decided to use two bits to encode the number of keys and four bits to encode the entropy of each digit.

if we assume that N can range from 4M to 16M, the encoding differentials between four regions of length 3M each.


From the figure, we can see there are more ctx instructions in thread 1 than in thread 2, and there are more ctx instructions in thread 2 than in thread 3.

thread 2 is more frequently interrupted than thread 1 when they are both enabled; and thread 3 is more frequently interrupted when either thread 1 or thread 2 (or both) is enabled.


Jobs may dynamically create an arbitrary number of threads, which may have di.erent execution requirements.

the worst case execution time (WCET) for the jth joboftask ti is the sum of the execution requirements of all of its threads, if all threads are executed sequentially in the same core.


However, servicing W with this new .. may produce a different measurement of ndb, because now only victim groups smaller than .. can enter the log buffer.


Note that e * is a loop in both GG and GH , too.

we have found our candidate gi+1 = hi+1 = g * .


This semantic representation frees the SCR generation process from depending upon the SysReq-CNL syntactic rules.

if the CNL evolves to capture Table 1: Case Frame Example.


In addition we are interested in the relations between quantities.

we de.ne properties on the quantities, and use these properties to de.ne test purposes.


After that, co-change graphs are automatically processed to produce a new modular facet: co-change clusters, which abstract out common changes made to a system, as stored in version control platforms.

co-change clusters represent sets of classes that changed together in the past.


The branch structure in Windows (and other products at Mi-crosoft) is typically chosen at the beginning of a release and re-mains mostly unchanged during the development of the release.

there is not a strong notion of short-lived vs. long-lived branches.


However, it turned out that parsing this generated HTML code is very tedious and often attachments which may contain patches cannot be accessed correctly.

we were not able to obtain a reliableparser within an acceptabletimeframe(giventhatthe timebetween the callforpapers andthe submissiondeadline was very short).


Often the associated licenses were digitally encrypted.

the usage started to scramble content and encrypt license.


The implementation described in this paper has a moderate overhead for a Ravenscar kernel and does not introduce much complexity to the underlying kernel.

they can be used for building high integrity systems.


The key observation is that in the protocol of Figure 511 in [6], if a nonfaulty process j participates in rounds r and r ' (and hence, in our setting, it participles in the SCC protocol with session identi.ers r and r ' ), and r<r ' , then it must be the case that r .j r ' .

there can be at most t(n - t)= O(n 2) rounds r such that a nonfaulty process i shuns a faulty process j starting in round r. Hence, there are at most O(n 2) rounds where the SCC protocol does not succeed.


The Accessible DOM will provide a superset of the functionality provided by existing platform-specific APIs.

the Accessible DOM will allow support of any platform-specific API through the implementation of thin-layer adapters that adapt the Accessible DOM interfaces to those of a particular API.


count Logical execution order (5) (5) (15) (15) (15) (6) (6) (17) (17) (17) it1 = it2 it1 > it2 it1  it2 it1 = it2 Task 1 is behind Task 2 Task 2 is behind Task 1 Task 1 is behind Task 2 Task 2 is behind Task 1 No relative progress order Table 1: Two MPI tasks executing the Poisson solver of execution.

we reduce the relevant state to those variables that capture progress through that control .ow.


Selective compilation currently employs pro.ling to .nd the subset of methods that were hot in the current run so far, and sends them for compilation based on a speculation that they will continue to remain hot in the future.

the methods that are compiled are those that were hot in the past, with no guaranty of their future hotness.


Finding all the extractable parallelism in its representation of dependences does not guarantee that affine theory can find all the extractable parallelism in a source program.

we avoid using the word optimal in this paper.


As any other Information System resource, wiki success highly depends on the interplay of technology, work practice and the organization.

the peculiarities of the organization will certainly percolate the wiki itself: users, roles, permissions, terminology, documents, templates or project milestones are already there before the wiki is created.


After the successors in case of DDR and corresponding register write instruction are all scheduled in VLIW, it s not necessary to keep the data in the output register of FU.

this FU is considered as recently free FU and is available to other instructions.


A cache hit occurs when a request for a message is sent out and at least one of the nodes that received the request, is able to provide a repair.

considering the whole network as a single cache, we de.ne hit ratio as the ratio between total number of cache hits to the total number of requests.


When the network quality is low, the transmission queue of a node starts .lling-up at a speed depending on the producer rate (the microcontroller) and, if the condition persists, it can become full.

to save power on the microcontroller, a simple approach could be to switch to the lowest possible frequency value (or even shut-o.)


Additionally, the iterative decoding strategy of [9], which they call joint decoding, requires high computational e.ort.

another challenge is to improve the performance of the decoding algorithm, also denoted as tracing algorithm.


Almost every student, including those grad students who had previously taken the undergrad course, was able to respond with valuable lessons learned during the exit interviews.

we were successful in meeting our standards: two truly distinct, yet combined courses.


FT-CORBA does not specify group communication primitives.

in order to provide for example active replication, FT-CORBA implementations must use proprietary group communication mechanisms [6].


Another issue is that these faults are roughly the same size .

a program with, say, ten faults has been changed more than a program with one fault.


(2) The exact nature of the service quality normally depends on the configured functionality.

it is reasonable to firstly select the functionality and to consider the related quality afterwards.


However, we remark that the original program had a space leak along a failure path that we were able to .nd and eliminate.

our experience with reference counting was mixed.


Upon completion of the GC, the block of memory will again be given to what is likely a different thread running on a different processor.

nursery blocks frequently cycle between predominant access from one processor to another for two reasons: 1) predominant access cycles from one thread to another and 2) thread migration between processors.


However, we may achieve savings of different magnitudes, depending on the speci.c thread/data mapping scheme adopted.

we now discuss the default mapping scheme used for obtaining most of our results presented below.


As hinted at inSection 3, behavioural declarations which de.ne the overall ordering process are still owned exclusively by eachof the client applications, while there is potential for reuse.

some behavioural declarations areso contained redundantly by all client applications, as indicated by the half-.lled circles in Figure 8.


However, with PNF, all objects accessed by each transaction must be known apriori.

this is not suitable with dynamic STM implementations [11].


In [16], Vallecillo argues that it is unrealistic to model large and complex systems with a single instance model of a single DSL, and that instead it is preferable to model di.erent facets of such systems with distinct instance models of distinct DSLs.

the broad survey of model and metamodel combination approaches Vallecillo provides, as well as his own viewpoint uni.cation technique are mostly aimed at the merging of interrelated models and metamodels.


Subgoal B and C are transformed to activity B and C in BPMN models according to Table1.

the intermediate sequence of executing activities is also B, C. Next, subgoal B is refined to its subgoal D and expectation E using Uncontrollability-driven Refinement Pattern.


Recall that since UnitTest is within the context of class pattern $$C, type $$C refers to a single type, not the list.

the body starts out declaring a local variable of type $$C.


Furthermore each stage has enough computation and memory accesses to require multiple copies to be running on the MEs in order to support high data rates.

a designer following the traditional approach of provisioning would have to choose a subset of the stages to place on the fast path and the remaining stages would be placed on the Intel XScale® core.


Gains in makespan are higher by 8% for m = .5 and do not drop much beyond m = 1.5.

using a value of m close to 1 is appropriate.


From both of our evaluations of comparison of work.ow executions employing di.erent optimizations strategies, we observed that the our predictions validate the measured ranking of di.erent optimization strategies.

we believe that despite of the small inaccuracies, our predictions can e.ectively guide the work.ow runtime environment for the selection of di.erent optimization strategies.


Observation 2: By Property 1 of Bi and Bj ,  |Bi n Bj |= n - f. (As noted earlier, we omit the round index [t]when discussing the sets Bi[t]and Bj [t] here.)


Using the pigeonhole principle one can show that if facts corresponding to yet further clones of the same subtree are added to B, the homomorphism h can be extended to such an increased f-block.


Nevertheless, [20] provides a mecha- nism called per-class mixin that permits to add roles to classes.


This may occur when the coe.cients of the existential variable are not coprime.

in order to project out a second variable, this union has to be projected again, and so on.


When applytitioners usually refer to techniques for acquiring and managing ing ourprevious approach on web applications, weface signi.cant * Corresponding author challenges.Foraweb application,eachdynamicallygenerated web pageis actuallyatextintheHTMLformatdisplayed atthebrowser side.

our previous approach is able to locate the constant stringsthat maygotothebrowser sidefordisplay.


Peers with small credit balances are incentivized to deposit tokens earlier than their expiration times in order to receive fresh tokens to spend.

when the coordinator adjusts timestamps on forest edges before extracting propagation bandwidths, promptly deposited tokens result in early timestamps that percolate up the forest trees, replacing timestamps of exchanges whose tokens were deposited signi.cantly after the block exchanges actually occurred.


This is necessary to make groups of components relocatable across directory structures and network domains.

the import function passed to a component must know about that component s associated URL, that URL has to be passed as an additional parent argument.


Hence, the probability of a query word wi generated by D is expressed by K , P (w | M ) =P(w | k)P(k | M ) (8) DTMiD i D k =1 where P(w| k) denotes the probability of a query word wi i occurring in a specific latent topic k, and P(k|MD) is the posterior probability of topic k generated by document model MD .

considering equations (7) and (8), the likelihood of a query Q generated by D is thus represented by .


As described in Section 4.1, the fast code generator also eliminates class initialization calls, whenever the VM indicates that the class has already been initialized at JIT compilation time.

the actual code that the fast code generator produces is not stateless it depends on which class initializers have been executed at the time the method is compiled.


we make the kind of a abstract by using kind polymorphism; a now has the kind bound in the t. branch.


Strictly speak ing, however, a Discourse Model contains references to objects de.ned in the Domain-of-Discourse and the Action-Noti.cation Model [10].

the designer has to pro vide these three models, which are parts of the so-called Communication Model.


3.2 ArraysasInliningParents Reference arrays contain pointers to other objects and arrays.

it would be bene.cial to combine an array with the objects that are referenced by the array elements, i.e.


For each Twitter ID, only 350 tweets can be received per hour and only 1000 tweets per day may be published.

a node can publish a tweet every 86.4 seconds and can receive a tweet each 10.29 seconds.


Selecting Beam Directions in Radiotherapy with an Evolutionary Algorithm Marco C.Goldbarg Elizabeth F. G. Goldbarg Carlos R. A. Mendes UFRN UFRN UFRN Campus Universitário, Lagoa Nova Campus Universitário, Lagoa Nova Campus Universitário, Lagoa Nova Natal, Brazil Natal, Brazil Natal, Brazil gold@dimap.ufrn.br beth@dimap.ufrn.br carlosraoni@gmail.com ABSTRACT Radiotherapy treatment planning aims at delivering high doses in the target volume while taking care to do not overdose other organs at risk.

it is an important issue to design a process for finding out ideal balances between those contradictory goals.


However, it is not the main focus of this paper to investigate different algorithms for making such decisions.

in our previous work, it has been noted that the effect of the con.gurations of geographic location of the database replica is not as signi.cant as the effect of the overloading workloads in increasing the staleness window of the database replicas [23].the analyser component can decide to stop an active database replica when it detects a decreasing workload that can be served by less numberof database replicas without violating the application-de.ned SLAs.


Instead, it is intended to limit temporary users to explicitly shared services and data.

even with xShare, temporary users may be able to exploit existing security flaws in the phone to overpower xShare.


Moreover, Social TV is not, by far, the most restrictive IDMS use case, and other scenarios require stringent synchronization (sync, hereafter) levels [1].

this motivates the development of adaptive and accurate IDMS solutions to compensate such e2e delay variability.


The underlying intuition is that if a user is in an unbound space, the space most likely to be selected by the localizer will be the nearest bound space theVoronoi site associated with the user s true location.

the size of the bound space s Voronoi cell naturally captures the spatial uncertainty associated with prediction of the bound space.


This necessitates the existence of a local maximum between the two minima, a contradiction to Theorem 2.

a single minimum (maximum) must exist at every negative (positive) nodal domain and the nodal domain is unimodal.


Recall that our primary goal is to identify the most frequently executed paths in the distributed system, so a useful tool will rank-order the inferred path patterns by count and then prune away most of the low-frequency path patterns.

we examine whether the top Npatterns that remain after pruning match the top Nground-truth patterns, or whether pruning causes some of those top Nground-truth patterns to be omitted.


These approaches have been mainly used in web applications while less effort has been done for other environments.

the problem of porting existing applications from desktop environments to PWDs ones remains an open issue.


However, if the .rst condition cond1 evaluates to false most of the time, then latest con.g will not be updated frequently.

speculating on the absence of the dependence between line 1 and 9 is a good choice, as this speculation is frequently successful, which enables the parallelism to be aggressively exploited.


e X:f(b),b:bl=0 L n-11 where tr{·} denotes the trace function and Gl = i=0,i=l 2 (2bi-1)LM,a(bi).

there are a total of 2n exponential terms to be generated when computing the LM,e(bl) value.


[6] investigated the performance bottlenecks of traditional database management systems and found out that 31% of the time is spent on synchronization and 35% on page and bu.er management.

a new generation of main memory DBMS has been engineered to remove these bottlenecks.


Unlike a primitive type, an object type is a polymorphic type in that it can stand for a set of types, which includes all types that have an IS-A relationship with it.

before entering the parameter value, the user must first specify the class of the parameter.


DOCUMENTING WEB TRANSACTIONS A Web Transaction is defined as a sequence of Activities with the associated execution flow that enables the user to accomplish a task and/or reach a specific goal by means of a Web application.

a Web Transaction can also be thought as a specialization of the concept of a workflow in a Web application, within the constraints implied by the underlying business process model.


There is a critical cycle (A,B,C,D,A) in the graph in Figure 4(b) that causes the program edge from A to B to be a delay edge.


More generally, the component composition selection problem is known to be NP-hard.

scalability is a serious concern, especially for critical systems.


Errors must no lead to complete collapse of the system.

the test must not reject moderately erroneous workers.


Basically, we identify each component of the framework as a valuable resource, which can be shared among various processes, and therefore may need some load balancing strategy to overcome the risk of low performances.

we rely on the cloud computing vision [10].


Hence, there would be no way to make predictions of new unknown objects.

categories can be seen as a product of interactions, containing perceived resemblance relations in the environment, prior knowledge and context of utilization.


This is due to the fact that the compilation times for subexpression elimination and scalar replacement can be optimizations on the QUADs were increased by disabling performed more effectively.

it is more effective on the frequency-directed splitting.


The PCMCIA card we use for our experiments does not 80 60 40 20 0 time (s) Figure 9: Inquiry Time Distribution -1 BlueTag allow point-to-multipoint connections.

the static node handles one connection to a smart-tag after another and thus establishes a connection as soon as a smarttag is discovered.


The subroutine Col laborationThresholds returns a list of integers in which the last element is the maximum weight in the collaboration graph W. Since one element from that list is discarded when the inner while loop exits, and since the inner while loop is guaranteed to exit (since it removes at least one vertex from the .nite graph W ' in each iteration and exits when W ' has no more vertices), the last element of the list L is eventually assigned to t (in line 5).

the condition W ' = W in the if condition in the inner while loop is satis.ed eventually.


As a result, callers or tests of the function may need to change to reflect the function s new interface.

crowdCode generates microtasks signaling the description has changed for each caller and test.


The system contains two identical servers of type A, and two of type B, each with its own queue.

each server is modeled as a separate task.


We have now expressed that changes in the exceptional behavior of strategy.compute and myStrategy.compute will always be re.ected in the set of exceptions signalled by the methods template and client respectively.

the addition of YourException to MyStrategy.computewill not require the modi.cation of the clientmethod.


The  HTML tag implements an input .eld and binds its value to the variable name.

the input .eld displays John as initial value and as the user types in the text .eld (on every key stroke), the changed text box value is propagated back to the name variable.


live size (log) (a) GC time (b) Execution time Figure 2: Performance of an FG collector and a BG collector relative to the best performance for javac ensure that there is enough space to collect the old generation even if all objects in the nursery survive collection.

very small nurseries allow better utilization of space but perform collection more often.


Unfortunately, manual code parallelization by programmers is a time-consuming and error-prone process.

compiler based automatic parallelization techniques have drawn much attention of researchers.


For example, estimating the remaining cruising range with the available fuel and/or battery charge becomes increasingly important.

our lead path is changing from torque to energy at the moment.


and the trade-off between automated and manual testing.

this paper is structured as follows: In Section 2 we summarize a common, simplistic approach and the involved problems of modeling the decision of automating testing.


Useful services always combine session management with other functionality, such as for example, the management of additional abstractions.

it is necessary to have a way of combining managed ADTs within the context of a single manger service.


The implications from each security incident are not always known at the beginning of, or even during, the course of an incident.

a written log should be kept for all security incidents that are under investigation.


This is only possible if devices are regarded as autonomous and independent resources in the system.

the Service Oriented Architecture (SOA) paradigm is very suitable for this kind of environment since, in this architectural model, the applications and devices that support them are abstracted like loosely-coupled services that can be integrated into bigger systems.


However, neither of these techniques is su.cient enough by itself.

wedesign a hybrid scheme where the vertical piece transfers are utilized for swarming and horizontal piece transfers are used for distributed feeding (see Figure 4).


In addition, to identify points of cause transitions, the above state-based analysis has to be performed at a large number of points along the failed run.

program state based analysis is dif.cult and time consuming for C programs [2].


A summary of the requirements for application elements using JUnitversions3 and4.

if the framework developer wishes to provide automated upgrade support, she often has no choicebut to create a refactoring tool by hand.


The subtype relation <: (de.ned for any class table CT) on class types is induced by the standard subclass relation extended in order to relate incomplete objects (Figure 2).

first of all, we consider an incomplete class class C abstracts D {... }; if D is a standard class, since C can make some methods of D incomplete, then it is obvious that an incomplete object of class C cannot be used in place of an object of class D. abstracts implements subclassing without subtyping.


Taking Amazon EC2 [24] for example, when a VM with 1 EC2 Compute Unit (equaling 1.0-1.2 GHz 2007 Opteron) has to be created for users on a physical server with current mainstream CPUs (such as Xeon X5680, 3.33GHz), the VCPU online rate may be about 30%.

in experiments the weight of VM V1 is set to be 256, 128, 64, 32, respectively, consequently the VCPU online rate of the VM is 100%, 66.7%, 40%, 22.2%, respectively, according to Equations (1) and (2).


Compiler optimizations, such as constant propagation, dead code elimination and strength reduction, are less bene.cial, because intermediate results need to be retained for the case of an interrupt.

compilation takes longer, the resulting code requires more memory and executes much slower.


This means, on the other hand, that the number of peers having the requested content (or its replica) on their own local storage is proportional to the replication ratio and so increases.

the network overhead required for the replica maintenance will grow with the replication degree and thus for all placement schemes.


After the client sends 2,000 requests, we crash one replica, which recovers 10s later.

during 10s, only3replicasareactive.We comparetwo strategies:inthe .rst strategy,when Aliph switches to Backup,Backup always executes k =1 request.


On the other hand, it is widely accepted that traditional modular structures and metrics suffer from the dominant decomposition problem and tend to hinder different facets that developers may be interested in [20, 30, 31].

to improve current modularity views, it is important to investigate the impact of design decisions concerning modularity in other dimensions of a software system, as the evolutionary dimension.


(timing constraints) We denote SPEC by the con- Vbr m junction i=0(Pi n<8i Qi), for state predicates Pi and Qi, and, response times .i.

given a speci.cation SPEC , one can implicitly identify SPEC and SPEC as de.ned above.


We denote a call to an abstract (mathematical) function f as ß = f(a), where a is the sequence of actual input parameters to function f and ß is the sequence of output parameters.

f might correspond to a call to some user-level procedure or to a built-in high-level operator.


However, by rule (2) of section 2.2, ListF (or a subclass) cannot be instantiated unless it is .rst composed with a class that ful.ls the TreeF-requirement, i.e., a class that implements that type.

the semantics of our encoding of a lower-bound on s are upheld for instances of subclasses of Bifunctor.


We also extend the set of literals with syntacticobjects of the form check(c) where c is an identi.er for an assertion condition instance, which we call check literals.

a literal is now a constraint, an atom, a higher-orderliteral, or a check literal.4 4 While check literals are simply instrumental here, note that theyare also directly useful for supporting program point assertions(which are basically check literals that appear in the body ofrules) [25].


Because timers events are repeating, the anticipating information remains at each node in GEvents of event Timer1..red() and event Timer2..red() until their deactivation conditions are ful.lled in event stop.

event Timer2..red() is anticipated during the execution order of event Timer1..red() and during itself.


Thus, a developer cannot easily speci.es all the places in the code that need to be changed in complete when planning the change.

it is very hard for a mining tool to infer such information.


clearly outperformed in orders of magnitude by the execution and hybrid strategies on macrobenchmarks.

in this section, we only compare the performance of the execution and hybrid strategies.


where t1 and t2 are the timestamps of the events, respectively.

if trigger1 and trigger2 were to produce events almost simultaneously, with trigger2 producing its output .rst, we would have a case of t2 <t1.


5.5 Native methods and re.ection The implementation of a native method is compiled C code that may depend on the exact type of its parameters.

a call to a native method is wrapped with a helper method that casts the generated interface parameters back to their original class types, and then delegates to the actual code.


Because of speculation locality, how we mark other edges besides e that leave v has little to no effect on s. If e is instead marked with Option 1 or 2, then s has no effect on the decomposition of v because it is collapsed and its thread boundaries are ignored at run time, as in Figure 5.

if we search for a decomposition for v without revisiting the decomposition of any of its children, it will not have a signi.cant negative impact on our .nal solution.


And we will use {SP, WS}to specify their values respectively in the following study.

given L1 and L2 data misses are represented as X and Y respectively, based on the samples from L1 and L2, two parameters ( and a can be calculated using Eqs.


In the case of CONTEXTERLANG, COP functionalities are implemented in the OTP library which adds many time-consuming operations due to the built-in fault-tolerance support.

it has scarce signi.cance to compare message sending to a CONTEXTERLANG context-aware agent with a basic function call.


In kernels which use shared memory, all threads both read and write data to the shared memory.

by deactivating some of the threads, the output of active threads might be changed too, and this will result in an unacceptable output quality.


The idea was to generate a possible solution which can either be a point in the problem space or a path from the initial state, and testing to see if this possible solution is a real solution by comparing the state reached with the set of goal states.

the installation time is signi.cantly reduced.


Since the operating system is unique, race conditions might occur in the I level device driver (access to the device) as well as in the II level one (communication protocol execution).

mutual exclusion devices must be added at both the levels.


In ContextChat, the variations to the basic behavior are clearly identi.ed, should be separated from the rest in the codebase, must be dynamically activated, and depend on the current context of the application as we explain in a while.

cOP looks like the natural solution for the requirements of ContextChat.


In particular, interactive video portal applications for MDEs have a strong demand on low latency for the presentation.

we discuss related work in terms of interactive portals in conjunction with latency issues in the light of touch interaction.


6 (c)), instead of letting the branch instruction jump to the middle of the translated fragment 1 which resides in the cache bu.er.

in this case, instructions 2, 3,and 4 are translated twice and appear in two di.erent translated fragments.


Instead, our approach relies on separating the stream formats from the main SAS Kernel using con.guration mechanisms to specify the formats at runtime.

sAS Kernel realizes four concepts: 1) End-to-End Tunneling, 2) Device Stream Speci.cation,3) Semantic data propagation through S-RTP, and 4) Service Negotiation.


The e.ect di.erent parameters have on the system performances is determined both empirically and from understanding the details of the architecture and code.

expert domain knowledge is encoded implicitly in the search tree.


The compiler performs shape inference andthen generates and executes the specialized code.

the secondphase is triggered whenever the program reaches the entry pointof the PIR.


On one hand, a migrated piece of mobile code should look to its new host for OS services such as the dynamic variable hostname.

a delimited continuation should not close over all of its dynamic context.


Because the trace recompilation is optimizing trace-JIT.

the goals of recompilation invoked by taken side exit in these existing systems, the are different from ours.


DEMAND FOR SYSTEM-LEVEL DEVICE MEMORY MANAGEMENT To deliver high performance, GPGPU computing not only relies on vectorized GPU processors to process data in parallel but also requires high-speed memory to guarantee fast data accesses.

a common practice is to integrate GPU processors with device memory on the same GPU board, which is connected with the system bus to accept dataparallel tasks.


However, at the basis of the forelem loop concept is the assumption that the index set pT can be precomputed, whilst still allowing the tuples to be executed in a random order.

this whilever construct is not further elaborated on in this paper.


For the f-conditional expression, because it can be of any type, this introduces a new kind of value for every type.

we need to augment pure evaluation with rules to handle this new kind of value.


Fortheselected benchmarks, the correlation coef.cient between the number of migrations and the number of transition events is about 0.94.

thenumberoftransitionevents,whichisvisibleatcompilation time, can be used as a good indicator to reduce the migration overhead.


However, end users are not able to directly access, explore, and combine di.erent sources due to a number of technological barriers: (i) Data is stored in heterogeneous formats, e.g., XML, CSV, PDF, JSON, and HTML; (ii) users do not know where to .nd required data sources; (iii) provided that they are aware of appropriate sources, they frequently do not have the means and skills to access them; and (iv) if users are able of collecting raw data from various sources, they are typically not capable of performing necessary data processing and data integration tasks.

end users can not, yet, tap the full potential of Open Data, but rather have to rely on applications built by others.


a callee object) and a call parameter but also client is available to indicate the client object that calls the method.

instanceof predicates can represent the same conditions that this, target, args, and within pointcuts in AspectJ can do.


This is since the IO handle and mvars via which it communicates are labeled dcPublic.

the RPI must send the labeled cell to the OPI for declassi.cation.


However, traditionally code coverage analysis is often performed with logic simulation.

corner cases may be missed and no proof on reachability can be provided.


However, a VMM failure can occur after an I/O controller delivers an interrupt to the CPU but before the CPU begins servicing the interrupt.

upon recovery,the CPU cannot acknowledge the interrupt, leaving the interrupt blocked at the I/O controller.Toresolvethis problem, there needs to be a way to clear pending interrupt states in the I/O controller without performing a full hardware reset.


Considering these speci.c metrics, we can assume that the higher the values for dit and noc, the greater the reuse, since inheritance is a form or reuse [4]; the more operations a class has, the less reusable it is.

high values of wmc contribute to decrease reuse.


Update} Counting commands from D that Ignacio does not know, we have d is 2 for Format and d is 1 for Update.

this algorithm would recommend Format to Ignacio.


4.1 Syntax To support acquisition along containment links between objects, we must have some way to distinguish between * defn class c extends c contained c { .eld * contains .eld * acquires .eld * meth * acquires acqmeth * } acqmeth tmd( t *) Figure 8: Jacques syntax extensions those links that represent containment in the sense of a containment hierarchy and those that do not.

in Jacques, the programmer must explicitly tag those .elds that represent a containment relationship.


Hitting in this row-buffer typically incurs 15 ns in DDR3-1333 whereas missing in it costs about 45 ns.


The method of typi.cation allows developers to identify generic needs of particular users then, under the commonly known auspices that these actions are tied to this type of user.

analysis of the design space is rooted in commonsense knowledge of the typical courses of action that the particular social types populating the design space perform: in commonsense knowledge of patterns of action to be precise.


In large-scale and dense networks, increasing the size of MON-Cluster yields a long logical diameter that demonstrates high stress per physical links and high delay to disseminate data.

this paper designates the logical diameter, of each MON-Cluster j at instance of time t is bounded by µ.


Today, we already know that it will be possible to generate a part of the code from the model.

the delay between the availability of the requirement document and the delivery of the code should be reduced.


We .rst note that the problem of .nd a replacement policy that optimizes any of the metrics used (hit rate, byte hit rate, or other commonly used metrics) is known to be NP-complete problem.

there have been many replacement policies proposed in the literature.


Then, the sensor nodes in each cluster can be encoded with the In-Cluster-Hypercube-Node-Codes, and the sensor nodes in the k different clusters with the same In-ClusterHypercube-Node-Codes can be encoded with the Out-ClusterHypercube-Node-Codes according to the definition 5 respectively.

the whole sensor network has been mapped into a k-levels- hierarchical hypercube model.


However, for system-wide instrumentation, virtual addresses alone are insuf.cient to distinguish code as different applications may be assigned the same virtual addresses in different address spaces.

code-cache indexing in PinOS needs a new scheme that can differentiate address spaces.


Because of space limitations, it is not possible to present all method tailoring activities in detail in this section.

we illustrate with representative examples and statements.


We believe ontological modeling of UIMA types can take advantage of existing ontology techniques to understand existing NLP annotations, identify equivalent annotations in different systems, or define common standard NLP annotations.

it can increase interoperability among different NLP components implemented under the UIMA framework.


The other essential addition, which is common to all the apps, is the filtering mechanisms that allow users to filter out sub-areas of renewable energy research that do not interest them.

a solar energy researcher can filter out researchers whose interest is in energy policy or wind power.


The requirements must respect the following syntax: (Condition | Subject) + Action + Object.

all the requirements must start with a condition or Subject, following by an Action and an Object.


In the last scenario where peers are online for only 20% of the simulation time, the first peer meets the other peers only rarely.

peer 1 stores on average 107.4 operations for 60.6 s (peer 2: 80.4 operations for 22.8 s, peer 3: 66.4 for 27.6 s).


A code fragment is a (not necessarily continuous) part of a source file, and a source file is represented as a sequence of tokens.

a code fragment is represented as Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page.


2.2.2 Inferring Inductive Invariants In general, writing inductive invariants by hand is very tricky since the programmer needs to specify the set of states after an arbitrary sequence of events.

veriCon includes a separate simple utility for inferring invariants using iterated weakest preconditions [5].


Synchronized addition of the SAM waveforms extracted from the same subband group emphasizes the SAM waveform.

the modulation depth during the embedding process can be kept small.


In each merge operation, it has to read the OOB area of each page in both primary and replacement blocks to check if the page holds the valid data.

(NRp +1) × Np pages are read in a merge operation.


Such an experiment would require some basic knowledge about product-line engineering and variability modeling.

it is recommended to perform either a special training session on such aspects in advance or use subjects in the experiment that have such background knowledge.


We adapt the software layer model (see Section 4.1) by a di.erentiation of ExternalCallActions into local calls and remote calls.

we keep the failure probabilities for local calls:  fpj(AlocalCall)= fpj (Beh) but incorporate the link failure probability into the calculation for remote calls: 2 fpj(AremoteCall)= fpj (Beh) · fp(L) we enable coarse-grained consideration of network reliability, without going into the details of more sophisticated network simulations, which are out of scope of this paper.


This change may a.ect an external call to these methods when the receiver type is either B or C. By comparing the outgoing edges from the node labeled C entry in the graph in Figure 5(a) with the outgoing edges from node labeled C entry in the graph in Figure 5(b), our algorithm identi.es that the target of the edge labeled bar() has changed.

our algorithm identi.es this edge as dangerous.


1 + - 1 c-1 APPENDIX C. ANALYSIS OF HETEROGENEOUS NODE CAPACITIES Assume there are still n physical nodes as before and each hosts v virtual j nodes on average.


This register represents an indicator for the service released.

both the development and the implementation of the services could be made and released in any other place.


As mentioned in Section 3.2, the RCG algorithm partitions the subject program and operates on each partition separately.

rather than the number of partitions in a program, instead the characteristics of the partitions (e.g., the percentage of the instructions that require state saving for being reversed) play an important role in determining the ef.ciency of the RCG algorithm.


In the next iteration, a portion of the dynamic state data on RM-Edges may have changed from the previous iteration.

the mappers corresponding to the changed RM-Edges need to be performed.


To the best of our knowledge, no one has studied the impact of the second type of passive spin-up on energy consumption.

we are striving to solve the .rst two types of passive spin-ups, i.e.


In the return stage, each sensor transfers at most B · Count · log(k + 1) bits of information.

the total cost of querying and collecting the re.ned histogram is l Nnl · (logB + ..)+N · B · Count · log(k +1).


Pointers to dynamically-allocated memory are initialized, directly or indirectly, using the return value of the allocation function call used to allocate that memory area.

our technique taints this kind of pointer by, as before, intercepting calls to memory-allocation functions that return successfully.


However, this internal storage reorganization does not consult with higher layers and has no knowledge of file boundaries, sensitive status, etc.

in addition to storing a file s sensitive status in the extended attributes, we found it necessary to store a sensitive-status bit in the per-page control area.


A class diagram is not designed to represent the same information as an entity-relationship diagram.

an evaluator needs to decide whether her comparisons will strive towards the ideal of information equivalence, at the risk or artificiality; or if she will use models with uneven information to achieve a comparison with greater realism.


Modern compilers generate code in the function prologue to reserve enough space in the frame for the function s local variables, as well as a linkage region large enough to pass memory arguments to any potential child function that the function may invoke, which takes an extra compiler pass to compute.

in this example, when A calls B, the execution simply moves values to A s linkage region.


Taking the TV voting scenario as an example, almost each STB event should be counted and the permissible counting error should be less than 1% in general.

we should use the reliable transmission QoS instead of best e.ort transmission QoS for this voting application.


3.2.3 Reducing the Size of body-variables Unlike the input parameters, the type information for body variables is not included in the Java binary.

their size must be computed during data-.ow analzsis.


The teacher then gets the study materials from the study entity.

in the problem diagram of the SATM, the machine domain is the SATM, the problem domain contains the education expert, the teacher, the study entity and the education course.


Since DCPU decodes aninstruction through thedecoder of thephysical CPU,its output is considered correctbyde.nition.

all theinstructions(decoded by the other disassemblers) whose format is not compatible with the format reported by DCPU are considered wrong and discarded.


In our implementation a peer s .nd successor response includes the membership of the successor s group.

it is possible to check the veracity of a peer by verifying its response with one of its group s members.


if the program has a recursive behavior).

after having shortly discussing the main issues of thread migration in the literature and its motivations with some potential applications, in Section 3 we outline the main contributions of this paper: a novel approach towards the provision of Java thread strong migration on top of the IBM Jikes Research Virtual Machine, exploiting some well-established object-oriented language techniques (e.g.


VARIABILITY AS CROSSCUTTING Variability management, as discussed in the previous section, is well known as a crosscutting concern.

in order to increase modularity, it is necessary to provide a clear separation between variability management and typical software development assets (such as requirements, design, source code, and test cases).


First, Android does not provide a callback to an external observer when the display of a screen completes.

aMC has no means of knowing when to compute the structure hash.


However, the test classes BugTest and Help-FormatterTest both contain other tests that create options before test13666 and test27635 respectively.

when the tests in these classes are executed in order, the tests executed before test13666 and test27635 call create() at least once, which sets the default argName value, thus masking the fault.


Each attack surface element e is assigned ascore (some function returning a positive number de.ned by the speci.c attack surface metric in question) score (e) , representing its contribution to the attack surface metric.

the attack surface metric of a program prog under authentication constraint a is: metric (proga)=score (e) e.surface (proga ) Note that elements will normally be tied to speci.c lines, variables, or objects of a program.


We can see SEIE(21)= SEIE ' (21)=[RA], in which 21 denotes the .rst instance of statement 2 in the traces.

the .rst executed statement 2s correspond to each other in the two executions, as linked by the dotted line.


This is true because though these different approaches had structured the requirements into different models, the semantics of these requirements and their dependencies have remained unchanged.

the composition specified on the basis of these semantics and dependencies in our RDL is applicable regardless of the requirements structuring approach.


Even more, as we detail in the next section, we also structured the code to make it is easier for programmers to keep track of which objects live in which memory areas.

the architecture is representative of an RTSJ application, but not of plain Java application.


Second, Internet-based applications are dominating how people receive information, communicate, and entertain themselves.

we are witnessing an enormous increase in IP-based multimedia tra.c, which is putting an enormous strain on the network.


Recall that lowerSet and lowerVec made use of operations speci.c to their underlying type, such as returnVec and bindVec.

our generalization has to take those functions as arguments:  lowerNM :: .


The number of parameters of induction schemes depends on the number of constructors of the corresponding type.

when we extend the type, the corresponding induction schemes also enlarge.


Short of building a tailored VM, users of the re.ective API are strictly limited to the capabilities that have been built into the VM.

practical, mainstream uses of re.ection are mostly limited to (structural) introspection, for example, as offered by the Java re.ection API.


To enforce the use of AOT_s with a speci.c pointcut value would require the use of a dependent type, which is not possible in Haskell.

this said, we can use the newtype data constructor together with its ability to derive automatically type class instances, to de.ne a new type AOT_ac that encapsulates the AOT_s monad transformer and forces it to be run with the pc_ac pointcut: newtype AOT_ac m a = AOT_ac (AOT_s m a) deriving (Monad, OpenApp, ...) runSafe (AOT_ac c) = runAOT_s (EPC pc_ac) c we can export the critical computation by typing it appropriately: critical :: Monad m ) AOT_ac m a Because the AOT_ac constructor is hidden in a module, the only way to run such a computation typed as AOT_ac is to use runSafe.


Both Emscripten and PNaCl aim to allow code written in languages like C and C++ to be run on the web, but in very different ways: Emscripten compiles code into JavaScript, and PNaCl compiles into an LLVM-like format which is then run in a special PNaCl runtime.

emscripten s generated code can run on all web browsers, since it is standard JavaScript, while PNaCl s generated code requires the PNaCl runtime to be installed; another major difference is that JavaScript engines do not yet run code at near-native speeds, while PNaCl does.


The consensus .avor we solve satis.es a weak validity property.

we introduce a new .avor of consensus, endorsement consensus, and use it to solve atomic broadcast with only 2f + 1 processes, thus showing that our consensus algorithms are useful to solve a distributed computing problem with practical interest.


However, he knows the notations of his domain that are often based on graphical symbols.

by using the domain notations, we can reduce communication issues.


Although in the system life-cycle the components change, the SA does not change (if the requirements still remain unmodi.ed).

the SA can be used as starting point for deriving adaptors to correctly replace (at run-time) components in the composed system.


Cross-iteration dependences in compression subregions rarely manifest at runtime.

we run compression subregion in parallel and use atomicity check at commit to ensure the dependence.


INTRODUCTION Strings are one of the essential data structures used in nearly all programs.

string optimizations have a large positive e.ect on many applications.


However, these proactive services have not been widely used, mainly because most of them continuously consume too much battery power.

for proactive location-based services to be successful, their battery consumption needs to be as minimized as possible.


At the end of the execution, because of Characteristics 1, 2, and 3, F[Y] is either t1 (if Ye is the .rst entry event for Y) or a value less than t1 (otherwise), and L[X] is either t2 (if Xe is the last method event for X) or a value greater than t2 (otherwise).

we conclude that F[Y] < L[X] in this case.


For JNI analysis, we observe it is suf.cient to transition state machines and check constraints at language boundaries.

the synthesizer inserts wrapper functions with generated code before and after FFI calls.


This can be explained by the fact that the size of a typical discussion of LSEdit is very small.

discussion archives contain interactions about the issues on new functionality, rather than on various problems and their .xes which would result in repetition of the same words.


This results in frequent function calls so that the save and restore of register can too often occur for a calling convention.

the compiler-generated code cannot satisfy the required real-time performance.


It also effectively exploits availability of failing runs.

our approach is both effective in exploiting positive evidence from passing runs and negative evidence fromfailing runs.


However, reasoning about the behavior and correctness of multithreaded code is dif.cult, due to the need to consider all possible interleavings of the executions of the various threads.

methods for specifying and controlling the interference between threads are crucial to the cost-effective development of reliable multithreaded software.


While running the ontology-based matchmaker as a Grid service, changes in the Grid environment must be detected and incorporated in OMM s knowledge base without interrupting the service.

we extended TRIPLE to allow for dynamic adding/retracting of facts and rules so that a stand-alone persistent service can be realized.


The ideia behind this architecture is to get a loose coupling between its layers, allowing their implementations to be minimally dependent on each other, that is, interchangeable.

the .rst layer s API was implemented to be agnostic to the underlying source of information, as discussed in Section 4.


Upon anycommand of thread t, if the current status of t u 1 (ii)given that w2 is strictly serializable, there is no transaction x in q T | Status= q u 1u 2 the sequence x1x2 ... that satis.es anyof the conditions C1 C4,is started and if the thread t chooses to serialize, then the status of and commits in w2.


By contrast, if the same software is used by a police of.cer assigned to the case, no such privacy .lter has to be installed.

a .lter rule may block transfer from the individual agent s beliefs, to the role s beliefs.


All the required technical enablers for building such backend already exist, and are widely in use in the form of continuous integration.

collaborative editing, constant builds and tests as code changes, and automated configuration management is not a mission for moon but something that is within the reach of developers today.


Comparison of buffering saturation at 8th second At first, the curve of Sequential varies drastically, the average availability rates of the first several frames achieve 100%, however, the availabilities go down drastically after the 7th frame.

using Sequential strategy indeed ensures a smooth Sequential Sliding window and Urgent Region First Stream Block First rarest-first Figure 8.


Other effects of switching from switch As stated earlier, arrows with switch are fundamentally more powerful than those without.

it was never our goal to demonstrate that non-interfering choice and state settability could provide the tools to replace switch outright, but rather that switch s power is often underutilized, and in those cases, switch can be replaced.


For simplicity, we think of the common application as the base specialization.

for each specialization target, the associated control flow and XHTML+XForms pages are taken as input to the generator and a deployable web application is outputted.


The downside of these large bu.ers is that if traditional TD mechanism is used, there will be high queueing delays at congested routers.

tD mechanism forces network operators to choose between high utilization (requiring large bu.ers), or low delay (requiring small bu.ers).


.ed M MIij smaller than the MIij for the original MSA.

a value of cij = 1 indicates that all shu.ed columns (i, j) showed a smaller MI than the original one, indicating a signi.cant coevoultion on the background of neutral evolution.


4.3 LeakagereductionopportunitiesinGCs Intheprevioussetofresults,thegenerationalGCshaveshownto bethebestonesregardingoverallenergyconsumption.Indeed,this effectis the result of performing alarge number oflocal garbage collectionsinstead ofglobal ones.

furthermore,thistypeofGCs use writebarriersto rememberthe referencestothe exploredparts ofthe mature region,the storedlarge objects(LOS region) andthe immortalobjectsstored[11].themainmemorydevoted to store these elementsis not accessedduring the non-global collections, except the phase when the pointers to these regions are updated, which occurs when the part of the stack that stores the writebarriersisprocessed.


R(e) as e does not contain any allocation e.ects.

the number of locations in w* is the same as the locations in w, by x using the pullback w1 1v(1w*.


Tokeepthe address ofthe replicas anonymous, there should not exist any replica-replica communication.

all communications mustbeperformedthroughthe clients.


It has a lower failure ratio and therefore a higher transparency.

context parts are more transparent while parts that are important with respect to the task are more opaque.


It is almost as good as the .owsensitive analysis in .nding kind warnings and errors, it is probably simpler to explain to MATLAB programmers, and it is likely more suitable for implementing in an IDE.

we would recommend that the .ow-insensitive de.nition of kind analysis be adopted for MATLAB, and that a standard be developed based on that de.nition.


We note that portability is an important property of interpreters, particularly for a new language implementation.

it should be possible to build the source code base of the interpreter on a large number of platforms.


The recursive call to closure is passed a (n - 1) × (n - 1) matrix, and so the total number of semiring operations done by closure for an n × n matrix is O(n 3).

closure has the same complexity as calculating transitive closure using the Floyd-Warshall algorithm.