Table 1: Classification of our Review (source: authors based in Cooper [4]) Characteristics Category Focus Research Methods Goal Criticism Identification of Central Issues Perspective Neutral Representation Coverage Exhaustive with selective citation (tertiary studies [10] [12]) Organization Methodological Audience General Scholars Practitioners  2.2 Problem formulation The primary goal of this study was to identify the types of research questions used in the secondary studies.

the central research question1 is stated as follows: RQ1 What are the types of research questions asked in literature reviews analyzed in the tertiary reviews [10][12]?


This way, removing such a variable or changing its value does not affect other features, but only the maintained feature.

this variable is not considered in the Selection interface.


Instead of considering one trace as representing the entire use-case, we consider one trace as one particular scenario.

we have a n-to-one mapping between traces and use-cases.


Although, only 4 out of 15 values are statistically signi.cant.

we can not draw any conclusion from these data.


We refer to the task of developing an organization-specific BA meta model as BA engineering.

in the context of this paper architecture refers to the model-based documentation of the business, and engineering refers to the process of designing an appropriate language to model the architecture.


Finally, we can use the alias construct to borrow a reference-counted pointer to achieve a form of explicit, deferred reference counting.

the programmer has complete control over where reference counts are manipulated.


The estimated asymptotic speedup can be computed by observing that as n1 ' becomes large the costs of the loops are proportional to n1 ' * 3.16 for the original loop and n1 ' * 1.29 for the SIMD loop (since the SIMD loop processes 4 elements per iteration).

the cost ranking functions predict a speedup of 2.44×, closely matching the empirically observed speedup of 2.5×.


As mentioned above, the FWL in this paper uses 15 widgets.

in order to make the total order of the desirability of these widgets, the number of combinations Figure 5: Examples of evaluation scales for (a) Thurstone s method and(b)Sche.é s method.


Geometrically, the Hadamard Ratio measures the scaled geometric mean of the lengths of columns in A.

the shorter the mean of the columns is, the closer the Hadamard Ratio (1) is to 1, and the more orthogonal the columns in A are.


When the context in which an expression lies satis.es ., the expression is guaranteed not to go astray.

the expression is specialized using T, which is a conventional constraint-based specializer.


Most embedded systems are also constrained for power.

reducing the speed, memory (code size), and/or power requirements is extremely crucial for such embedded applications, as reducing the processor or memory cost can result in huge savings for products with millions of units shipped.


As M ensures strict serializability for all programs on two threads p and two variables, we get a contradiction.


However, Android, and its Linux kernel perform write operation with maximum size of 512KB due to IO scheduler policy.

packed command is important function to pack up diffuse write operation into large size IO at device driver .


(2) The matrix of relevant NFRs is expected to help developers to identify the important NFRs for their particular system being developed.

developers would be able to discover which NFRs should get attention in the project they are working on, depending on the type of system and/or the system application domain.


However, each event class should stores the list of possible state The State Event Design Pattern Page 5 changes for a given event, i.e., the subset of state changes (source state, target state).

each event subclass holds a behavioral part of the FSM, and while an event occurs, it identi.es thanks to its key mapping (behavioral part) the future state according to the current one.


These nodes are the ones which follow node k in schedule SG(i) or axe the nodes from subsequent schedules : SG(i+I), SG(i+2),..., SG(h) where h denotes the height of the tree of DDG as per topological ordering.

varSet(SG(i),k) can be found as : Varse~( SU ( O, k) = oj:~> k UV S( SU( O, j)O[O,:~>_~>,UV S L(p) ] where, UV SL~p) = Uv.esG(p)UV S(n) .


The elements in the set are instances of the FAMIXMethod class (which is also annotated with @rdf annotations).

we trigger the generation of the RDF statements for the FAMIXMethod class as well, repeating the process described above.


On an ef.cient and satis.ed quantum q, the allotment is the same as the desire (aq = dq) and A-GREEDY increases the desire (dq+1 = .dq) after the quantum.


The same element can be child of different elements, as happens to  element that can be child of ,  or  elements.

it is necessary to specify an ELEMENT primitive entry for each different pair of parent and child elements.


In fact, if there are k factors, given that the n-th factor has ni levels, a full factorial analysis requires n experiments: k n =.ni (1) i =1 It is easy to see that n can grow very large even with a relatively small number of factors, due to the product in (1).

it is not always possible to run a full factorial analysis, because of constraints on the overall running time of simulations, or on the amount of output data to be collected and analyzed.


However, those mocks were not sharing their behavior (i.e., the writing of a text in a mocked .le would not have effect to the reading of the same .le from another mock), and could only be used when given as input to the CUT.

such an approach would not work on a class like the one depicted in Figure 1, as the object interacting with the .le system is not given as input to the CUT.


In addition, we are interested in the companion hyperplane that forms the back face of the tile.

it is constructed by going backwards on the other hyperplanes, represented by a negative linear combination of the hyperplanes, and is given by: hi.D = 0. h.=hi -kj .hj .


For example, if a job j has sj =27s, and the time slots have intervals of 25s, the tasks of j cannot be executed until time 50s.

figure 4 shows C for Approach 1 is over 2500s, which is about three times longer than Approach 3 s C. the results show that for Approach 1, there is tradeoff between being able to handle larger workloads, and achieving a lower C. 5.2.3 Effect of Workload Parameters In this section, the effect of varying different workload parameters on system performance is discussed.


Other architectural techniques like context buses or HW support for task migration are orthogonal to the OSIP technology.

those can but need not to be utilized in order to integrate OSIP.


Finally it should be noted that the above optimization only eliminates labels corresponding to dependence instances exercised along the path for which a specialized node is created.

greater bene.ts will be derived if the path specialized is a frequently executed path.


If we take as D the set of all values, then this must include also .-abstractions.

to de.ne the semantic interpretation of types we need to de.ne the type of .-abstractions (in particular of the applications that may occur in their bodies) which needs the subtyping relation, which needs the semantic interpretation.


0=z=b Now recall that if a node q gets failed on level g during its m-th getName, then there is only one process failing q at that point.

for any level g, Yp,m,n p,m is an upper bound on the number of times a process gets failed on level g. Clearly then Y is an upper bound on the total number of times a process gets failed, which is X.


Closures, known at least since Steele s Rabbit compiler [17], allow the code to be shared, but also allow each object to have its own set of free variable bindings.

an alternative implementation would be to treat self as a free variable that is captured when the closures for an object s methods are generated.


The pattern p will have the categorical values of 1,2,3,4,5 corresponding to the {unknown, ramp, periodic, random, .at } patterns present in the data.

value of f2 p, and is extracted for each of the selected time series of interest, Ti.


Considering the foreign error probabilities as being independent and identically distributed random variables, the probability of not having a foreign translation error along the cycle is ci -1 (1 - Ef ) Moreover, compensating errors, i.e., series of independent translation errors resulting in a correct mapping, may occur along the cycle of foreign links without being noticed by p1 (which only has the .nal result qn as its disposal).

assuming T1.2 correct and denoting by d the (possibly high) probability of errors being compensated somehow, the probability of a cycle being positive is ci -1 ci -1 (1 - Ef ) + (1 - (1 - Ef ) )d = p(dcid, Ef , d) while, under the same assumptions, the probability of a cycle being negative is ci -1 (1 - (1 - Ef ) )(1 - d) = 1 - p(dcid, Ef , d).


Because the original Smalltalk Refactoring Browser focused on object-oriented features, most of the other refactoring tools do, too.

eclipse doesn t have much support for changing package boundaries or for refactoring plugins.


In most cases the problem is NP-complete, since the minimum multiprocessor scheduling problem is NP-complete [Garey and Johnson 1979].

*NSF TeraGrid Project http://www.teragrid.org most of the literature deals with .nding good heuristic solutions.


4.2 NFRs in Feature Models The NFRs represent constraints on functional requirements.

it is natural to add NFRs to the features, as shown in Figure 3 (the dotted gray boxes).


Rather, they are modeled by descriptions (metadata) which are interpreted at run-time.

whenever a business change is needed, these descriptions are changed, and can be immediately reflected in a running application.


As with Java and MultiJava, RMJ source code is compiled into standard Java class .les modularly, one .le at a time.

rMJ source and compiled .les interoperate seamlessly with Java source and compiled .les.


4.2 Simulation Results In this section, we present the simulation results for the proposed cross-layer allocation scheme and we compare the performance of the new scheme with the performance of WiMedia solution using TFC.

we use the proposed WiMedia data rates (see Table 1).


Signature violation in DrScheme beyond the reach of the framework we had introduced, which was already too complex.

we decided to instead introduce properties in the concrete context of programming and add support for them to the DMdA languages.


The JIT compilation of the bytecode (or even its recompilation in order to apply further optimizations) is reserved to heavily-used methods, as it is an expensive operation that increases signi.cantly the runtime.

the NPB-MPJ codes have been refactored towards simpler and independent methods, such as methods for mapping elements from multidimensional to one-dimensional arrays, and complex number operations.


As a result, we could confirm that the integrated model is effective in improving the quality of requirements specification.

it can offer correct and sufficient information to the following phases and also the final product can be implemented so as to meet it.


Implementing this program in NOX would be dif.cult we cannot run the two smaller programs side-by-side because the rules for monitoring web traf.c overlap with the rules for monitoring traf.c by host.

we would need to rewrite both programs to ensure that the rules installed on the switch are compatible with both programs e.g., installing two rules for each host, one for web traf.c and another for all other traf.c.


They give a quadratic-time algorithm for the server version of makespan.

our algorithm runs faster and also .nds all non-dominated schedules rather than just solving the server problem.


The problem in this program is that after safely retrieving the number elements that are to be copied, there can be a concurrent thread that modi.es the source vector before the method .nishes (for example, a concurrent thread could remove all the elements from the source vector).

when the execution of the addAll method happens, the information about the number of the items that are being copied is stale, and an exception will be raised when it tries to access elements that are not there anymore.


ExperimentalSetup As we anticipated, it is much faster to clone workers than to boot them (.ve seconds vs. two minutes).

our experiments look past this major advantage, and instead examine the value of micro-elasticity and warmed caches by comparing cloning to an idealized cloud where new workers boot instantly at no cost.


A standard check on formal requirements is to verify that they are consistent, but is not su.cient to assure that the requirements are correct, and that they specify exactly what the experts have in mind.

the use of formal methods, traditionally oriented to design veri.cation, has to be re-thought before being applicable.


Paths a-b-c and d-c both have toggle rates of 40% (|.toggle(p)| =2 and Xtot = 5).

if only one of the paths has negative slack, the error rate is 40% in this example.


But it only makes sense to create new strands when there is a region that is relatively empty of strands.

we plan to extend the programming model with three mechanisms: a mechanism for creating new strands, a mechanism for reading the state of nearby strands, and a mechanism for global computations (i.e., reductions) over the whole set of active and stable strands.


To overcome the limits imposed by this method (restricted public, limited problems and tiresome validation process), we would like to open this problematic to the expert community.

we propose a collaborative website sharing bad practices in ob ject oriented design to improve the use of patterns.


behavior of the sCPS as a whole that cannot be accredited to any of its individual constituents alone.

software engineering for sCPS becomes a significant challenge: a sCPS practitioner has to have working knowledge of multiple (and usually not well-related) areas software architectures, real-time and embedded systems, distributed systems, autonomic agents, and control systems.


Third, the misspeculation detection and recovery latency can be hundreds of cycles1, because misspeculations are detected by the trailing execution signi.cantly after they occur and require restarting the speculative program from the trailing program s state.

mSSP embodies an aggressive software speculation mechanism and requires an effective speculation control system to achieve robust performance.


In a public cloud environment, VIP con.guration tasks happen at a rapid rate as customers add, delete or scale their services.

vIP con.guration time is an important metric.


Example of working with multi-valued properties Rule processAnAttribute in Figure 5 illustrates the binding of the variable A to each of the many attributes of Class C. The concrete syntax makes no distinction between multi-valued and single valued attributes.

for a single Class with n attributes, n Somethings would be created.


All other programs continue to work without type annotations.

switching the underlying type system of an ML-like language to MLF will not break any existing programs.


3.6 Soundness A program with unknown components is an abstraction of a fullyknown program.

the semantics of the abstracted program should approximate the semantics of any such concrete version.


The fuzzy control process is very similar to the reasoning process of human.

fuzzy control is very feasible for the study on self-adaptive software with the characteristics of vagueness and uncertainty.


Finally, on top of the core APIs, there are the vast amount of derived, nonetheless equally critical, information and artefacts such as documentation, tutorials, wizards and recipes, and sample code and applications for programmer consumption.

modern programmers must master the necessary skills to effectively work with this vast amount of information artefacts and to overcome potential learning barriers [6].


The other doall block, containing only PDG node B, is reassigned as a sequential node, and then merged with the other two sequential blocks to form a single sequential block that contains the PDG nodes A, B, C, D and J.

for this loop, the PS-DSWP algorithm produces two stages, where stage 1 is a sequential stage and stage 2 is a parallel stage.


Thisis because, Scarab appliesa caching mechanism to, not all of, but some of the database accesses, presumably selected by ef.ciencyand safety criteria.

it is not possible for test-based pointcuts to conjecture such properties from parameters in the unit test cases.


and B!,andthenapplyingreconciliationonthenew tile A!B!A!IB!I.

reconciliation can be viewed as an algebraicoperationmappingtilestotiles,!


Next, from Figures 6 and 7, the variable a will be of type INTEGER in the statement c ~--a+ b from the second iteration on.

the single assertion in Figure 9 need not be executed beyond the second iteration because if a type error does occur, it will occur within the first two iterations.


On the other hand, although these results are tight to the everis context, they offer useful evidence for organizations that have similar context.

researchers and practitioners may also use the evidence provided by this paper in similar contexts for the inception, design, and application of SRAs.


This allows two mutually untrusting components to transfer funds, provided that they both trust the mint and purse system.

if the payer has a payerMainPurse account, and the payee has a payeeMainPurse account, then the transaction may take place as follows: // payer creates temp purse def tempPurse = payerMainPurse.makePurse tempPurse.deposit(100, payerMainPurse) // payer passes tempPurse to payee payee.acceptPayment(100, tempPurse) // payee payeeMainPurse.deposit(100, tempPurse) A feature of the Grace implementation is that each mint stores a ledger that tracks the balance of its purses.


For this application, we do not currently need to represent two-dimensional information.

we assign a constant value to the brightness component of the coloring.


Executing the methods concurrently alone may not be suf.cient because objects used in the invocations need to be shared or linked properly.

we derive an invocation context, i.e., the parameters (and receivers) to be used while invoking the methods in M. We analyze the execution trace associated with the test case involving each method in M. From the location of the lock acquisition in the trace, we search backwards to identify the data dependence of the lock on the method s parameter.


Note that while both the nests have similar data access patterns as far as accesses to array Aare concerned, the second nest also exhibits data dependences.

selecting a suitable data tile matrix/iteration tile matrix for the second case is more dif.cult.


Note that the object type provided in the assertion does not serve as an e.cient .lter, since the program is specially designed to create only objects matching the type examined in the assertion.

the .elds of virtually every program-generated object need to be examined.


To obtain a merged model that maximizes the combined effect of all parallel operations, we propose an automated approach for finding the optimal merging sequence that maximizes the number of successfully applied operations.

we adapted and used a heuristic search algorithm to explore the huge search space of all possible operation sequences.


However, those weights are not related to a speci.c metamodel element, but are used for all metamodel elements.

extending EM-FCompare is a complex and tedious process, which requires extensive knowledge of Java, Ecore, and EMFCompare itself.


The analysis of the application tier CPU utilization in Figure 7(e) corresponds to the CPU-bound implementation of the BLR.

the HSM operates well based on the average application tier CPU utilization, which results in an approximately monotonic throughput increase per scale-up step (Figures 7(b) and 7(a)).


brand new functionality can be added easily to the software.

the documentation of the API is a serious task among others, so that, at the end, it introduces the possibility of similar SNA implementations in di.erent programming languages and environments.


However, a strategic plan for IT has the following additional di.erences: it partially realises the institutional strategic plan, and so must provide some implementation details as well; theplansproduced arebound to changefrequently, over time, in ways that were never anticipated; and mostdecidersdonot masterthechangeprocessnorthetechnology that engenders them.

the strategic IT plan describes applications or solutions for particular business departments or functions, as well as technological details such as infrastructure requirements, software upgrades and architectural detail.


The very frequent pointer manipulation functions can also be the bottleneck of the queue management system depending on the application requirements and the hardware architecture.

the overall actual performance of a memory management scheme can only be accurately evaluated at the system level.


As mentioned earlier, there is no encoding space left in THUMB ISA to specify priorities; thus, we use offset locations in the stack as an encoding of priority values.

offset assigned to a value in the stack is its compiler designated priority value.


In a run of A.T using D ' ,since T implements D using D ' , each output d by T corresponds to a legitimate response of the failure detector D at some instant t between the time the emulator issues the input to T and the time T produces the corresponding output.

the emulation of A s qry fd instruction makes it appear as if the qry fd instruction takes e.ect atomically at t, receiving the response d from the failure detector D. Intuitively, therefore, corresponding to every run R of A.T using the failure detector D ' ,there is arun R ' of Ausing the failure detector D such that R and R ' have the same failure pattern and the same input and output histories.


B-SCP does not address the requirements evolution problem of strategic IT, however the Map does.

we integrate Map with B-SCP to provide evolution mechanisms in the B-SCP framework.


The student who read this pattern may .nd new ideas to design his / her learning activities, because pattern languages can become concepts to comprehend the reality and amplify the ability of recognition.

the method of pattern language provides the way to understand the existence of problem and the clue of the solution.


Separation of concerns is clearly of limited use if the con- cerns that have been separated cannot be integrated; as Jackson notes, "having divided to conquer, we must reunite to rule" [32].

any approach to separation of concerns must have a corresponding integration approach, to permit the synthesis of software that deals with multiple concerns.


The Zhi# compiler framework3 provides two extension points for semantic analysis and program transformation that can be implemented by compiler plug-ins to make external type de.nitions available in Zhi# program code.

external type de.nitions can be seamlessly used with features of the C# programming language such as, for example, method overriding and user de.ned operators.


Note that activities can be called independently, i.e., without the need for entering into another activity.


The adaptive nature of the Throughput (calls/sec) 1200 1190 1180 1170 1160 1150 1140 384 512 640 Heap Size (MBs) Figure 4: Throughput measurements for telco collector makes this a di.cult property to measure: if we double the number of processors available for GC, and this increases the GC rate, then we ll do more collection at each pause, changing the execution signi.cantly.

for this experiment, we restrict the collector to fully young collections, use a .xed young generation size, and use a total heap size large enough to make old generation collection activity unnecessary.


This exploration is complicated by the fact that LHPNs typically have an in.nite number of states.

to perform state space exploration on LHPNs, this in.nite number of states must be represented by a .nite number of convex state equivalence classes called state sets.


During startup of the microcontroller, however, interrupts are disabled and have to be enabled by the main process before an interrupt can .re.

the second step is repeated using a worklist algorithm until a global .xed point of the main process is reached.


Although the Espresso heuristic logic minimizer is very efficient performance-wise, cover minimization is a very hard problem and a strategy based on direct processing of the feature model expression is destined to failure.

we have developed an approach based on a partitioning strategy that decomposes the feature tree into multiple independent partitions.


The requirements requested by the 3 customers are R = {, }, R = r ,r }, R = {} rr { r and the profits of them ,,w are 30,25,20 , respectively.

the total 1 342 783 8 ww requirements requested are R = {, , r }, R = r ,,, r ,rr } 1 2 3 rr {, rrr ,, R = {,rr ,r }.


We are still in the process of implementation interactive code annotation in ASIDE.

the screenshots in this section are of our design, not a working prototype.


window update messages and mouse movements).

this sudden burst is accompanied with a jump in CPU demand.


To provide more comfort to the elderly person it makes more sense to present the particle recipes in a user specific order.

the service implementation within the recipe particle component has to adapt its implementation towards the user preferences.


With the help of our tool, business analysts and developers can reference the same business processes.

our tool supports the coevolution of the business processes and the e-commerce system, improves the responsiveness of the software system to changing business requirements, and reduces the cost for the software evolution.


Unlike these object-packing techniques, which only pack a part of objects into one file, our method packs all objects into one file with a dynamic and precise space management.

all open/close and delete system calls can be eliminated completely.


They keep track of the types of all the elements in the list, and at the same time determine the length of the list.

by using the same signature ts three times for the three occurrences of TList, we now establish statically that all three occurrences have exactly the same shape.


In this case, the closest cluster is between cluster 2 and 5 with shortest distance of 0.4.

cluster 2 and 5 are grouped into cluster (2, 5).


The starting point of the paper is that each artifact is able to recognize spatial relationships at certain points in time, and stores time intervals of constant relationships in its local repository.

it is possible to relate such intervals with qualitative temporal relations, which build up the basis for spatiotemporal reasoning.


In the worst case, the callee assigns them to static .elds or passes them on to other methods.

we mark all actual arguments as GlobalEscape.


For instance, although if-then-else constructs are expressions in Lustre and can thus be inlined, such inlining would not be possible in C where if-then-else is a statement.

we did not inline variables de.ned through an if-then-else expression.


Finally, we should emphasize that our approach to semantic integration is focused on the conceptual level, as advocated in [12].

our ontology is a reference ontology, i.e., an ontology that is constructed with the sole objective of making the best possible description of the universe of discourse, with regard to a certain level of granularity and viewpoint [11].


Since the SPE cores are meant for sequential processing, loop-unrolling will generate optimal computational speed.

even for two halves (n = 16) we avoid the use of for- loops and arrays of vectors, where possible.


It is a universal property that applies to all models with notions of restricted inter-domain interaction.

it applies to all non-shared-memory models, most notably CSP (communicating sequential processes [13]), and APGAS (asynchronous PGAS [19]) languages which require that mutation is done locally to an owning place/region.


We maintain fat parent pointers PF from fat children to their fat parents.

we induce a fat segment tree F of height £.


In some cases, the analysis computes a unique source statement at which the incorrect value that reaches sr(E ) is generated.

for this case, this statement de.nitely caused the exception in execution E. we classify sa(E ) as a de.nite incorrect assignment, and we know that it is the cause of the exception.


(1) This Work Law holds because, in our simple theoretical model, P processors can execute at most P instructions in unit time.

with P processors, to do all the work requires at least T1/P time.


Apart from these issues, since tags are textual in nature and do not contain any additional semantics, these tags cannot be processed by machines to infer other knowledge.

it is of paramount importance that folksonomies are studied in order to find semantic representations for tags on the Web.


Additionally, 1) does not require any speci.c implementation or synchronization considerations.

approach 2) generates a separate copy of the indexes for each snapshot by eagerly duplicating the index when a snapshot is created no synchronization is necessary as no indexes are shared but reorganization speed decreases.


However, such a new class may not support the (implicit) contracts associated with the interface implementation.

we provided minimal assistance to Pex by describing which implementing classes can be used for interfaces.


If the values are not within this boundary, the constraint is violated.

a constraint speci.es one benchmark component whose values is reduced to a single value with a speci.ed reduction component and de.nes one or several conditions which must be met by the reduced value.


If for instance our mailing components A and B are used in a high-security application domain, the tests may look different than when they are deployed in a leisure environment.

tests must be described in a way such that both the components and the tests can be reused in other contexts.


For instance, continuing with the example discussed earlier (Figure 3), let us assume that the sample airfares section is always preceded by the element  which contains a label for the section, Sample Round-trip fares between: .

one of the extraction patterns would be a  element that immediately follows a  with the text Sample Round-trip fares between: .


Design and Implementation 4.1 Context Representation Inthissection,we.rstpresentourcontextrepresentation,andthendiscusshowitisusedincontextchecking.


Optimized string objects have a variable length like arrays, but also .elds like objects, so neither of the two previous bytecodes can be used.

we introduce the bytecode newstring that is similar to the bytecode newarray and expects the string length on the stack.


Essentially, programmers implement the near equivalent of a PGAS or RPC runtime within the application.

dynamic memory management in the existing non-coherent programming models tends to be either: 1 The Berkeley UPC 2.14.0 we used in the evaluation imposes a static limit of 64 MB per thread for dynamically allocated memory.


However, the standard ASCII codes are a .nite known length.

since the number of phases is small and known, a parallel radix sort will be most e.cient in this case.


Still, the software can work similarly even on di.erent hardware and therefore it should not create a big barrier for communication.

the biggest problems with compatibility can be found from the evolution of the software and from the new features it has.


Furthermore, an exit exception means that a decision was made to terminate the process, and a programmer should only override that decision if he knows what he is doing.


These unique codes are the unique features of zip files.

the APK files using the zip file structure have these unique codes.


.joiner work(vi) ifj> 1andk= j+2 Version0of the actor is same as the original actor.

the workdonebyversion0isthe originalworkt(vi).Inversion1, there are2copiesof the actor thatdo half thework as the original actor.


The use of preprocessor directives also enables innerfunction statements to behave di.erently depending on the feature selected for a given product con.guration.

the feature-oriented approach can provide the adequate support for changing an entire function to a .nal product.


Notice that our mappings only contain instances with complete information.

as opposed to previous work [13, 21, 16], we make a clear distinction between instances participating in a mapping and incomplete instances that are used as representatives for spaces of solutions.


Thus, this mode relaxes safety the client may initially see an inconsistent view (although one generated using read-consistent data) and, since his updates are not propagated, has a different impression of the global state.

the state must eventually be converged, and so, the transaction is concurrently re-executed in consistent mode to .x the client s view and apply modi.cations.


Thirdly, the devices are highly resource constrained in terms of processing ability, memory capacity and communication ability.

a testing approach that is highly intrusive to the target system under test may affect the actual result of the testing.


Node constructors new n(ba,bc) consist of an identi.er n, the node name, and two statements ba,bc, the initializers for as attributes.


Thus, the chance is higher in TriMedia for resource con.icts resulting in longer schedules and hence, higher costsforpredicated if-statements.

more if-statements are splitfor theTriMedia thanfor theEVP.Fig.8(a) showshigh speedupsfortheVLIWprocessors, whereastheARM shows smaller speedups.


1) which gives an overview on the processes executed within the specific application domain, based on the description of service modules.

processes may be classified into process classes (e.g.


The effectiveness of pipeline parallelization is mainly determined by the execution time of the longest stage.

the primary objective of a pipeline partitioning algorithm is to balance the load across the available cores.


[32] proposed implicit ownership annotations for regions.

classes that have no explicit owner can be allocated in any static region.


And since the current is constant the areas 1 to 4 under the line of voltage drop are proportional to the amount of energy delivered in each time period.

the energy capacity available by the battery pack can be divided into four partitions depending on the voltage range as follows: 3.2 V 2.8 V 31.25 % of 21600 Ws .


e1 and e2 are not comparable under .x and they are not protected by the same lock.

race the data race can be detected by comparing events generated in di.erent threads.


On the contrary, the cyclomatic complexity metric is found as an insigni.cant indicator for the FT defect type as well as ST and Field defect types.

this metric cannot be used to predict any of these defect types in company data sets.


Secondly, it is based on the assumption that in any systems development initiative, there will be fewer goals than processes, fewer processes than tasks, and fewer tasks than information.

the pyramid structure is a useful means of organizing and describing types of requirements.


only node 2 has at least 3 nodes outside of its set, so all of the conditions (i)-(iii) fail.


In contrast to methods, events do not have a behaviour of their own, and events do not belong to a particular element they are shared among di.erent elements.

event parameters can be contributed in many di.erent ways, and by di.erent elements.


Or from a document file in a PC, the user can retrieve paper documents printed from that file and the handwriting on them.

our system can realize efficient document retrieval using handwritten information.


c 1 can be checked using the causality interface of actor b, without knowing explicitly the causality interface of actor a.

our technique achieves a measure of modularity, in that details of a composite system can be hidden; it is only necessary to expose the causality interface of the composite.


This eliminates tedious and repetitive tasks, provides a good model around which to structure (part of) the application, and prevents many common mistakes and pitfalls by providing a good general purpose implementation for common operations.

the goal of this research is to propose useful abstractions for the coordination of application components, and to support these abstractions through a suitable coordination middleware.


3.2 De.nition of the global .tness function The main purpose of software component identi.cation techniques is to promote the reuse of recovered components as building blocks for newly developed systems.

the identi.ed components must exceed a certain threshold of quality to be potential candidates for reuse.


Unfortunately, this is not a factor that the user can control when compiling Haskell programs with GHC, as GHC performs many code transformations when optimizing a program, with a particular tendency to push code towards branch leaves in the hope that this will reveal more opportunities for optimization.

when examining the code generated for of.oaded kernels, we often see branches with relatively large amounts of code in both of them, with many instructions common to both branches (after alpharenaming variables to match them up).


Calling force on the expression mapg v1 returns map, but since map is not bound at the root let we go no further.

to evaluate this expression we will start by evaluating v2, and thus map.


Rule CO E R PRO P is the counter-part of Rule PRO P CO E R, but we do not need additional hypotheses here since the proposition judgment is stronger than the coercion judgment.

other coercion typing rules can be understood under the light of Rule TE R M CO E R. In particular, the judgment G f (S f t ) C s is meant to be used when some judgment G, S f a : t holds, which by extraction implies that G, S f t : * coercions G f (S f t ) C s need not assume that G, S f t : * holds.


In addition, one constant value, the integer 100, is also accessed.

the static reuse distance between the two accesses to x is 5.


The handles needed by the marking system to locate the objects, can consist of any attribute at all.

the course administrator is able to select handles that have no bearing on the rest of the system.


Even though QUPER has been evaluated in several steps, no full evaluation including all concepts of QUPER has been performed.

an evaluation of the complete version of the QUPER model where all views (benefit, cost, and roadmap) and the use of QUPER s tool support is needed.


This algorithm is more complex than the previous because it is necessary to consider the flows with soft temporal constraint where it is not possible to know a priori if data is available or not.

we propose to use a principle similar to the one of semaphore in operating system field.


Otherwise, the last node was inserted from the slow path.

we need .rst to update the entry in the state array corresponding to the thread whose ID = enqTid (clearing its pending .ag), and only after that can we update tail.


There are a wide variety of Open Source solutions covering basic ICT needs of any organization, from content management systems to decision making tools or project management software.

it is not a development issue but rather select and integrate different existing tools and define the flows to support the information peculiarities of each organization.


Rule SC, Submit Constraints: We consider theparticular casein which the constraintdomain isthemediatorialdomain(theotherdomains canbeprovedina similar way).

s is the mediatorial store M, Sj is Mj , Mj = p .M, Hj = H, Fj = F, and Rj = R. We assume thatµ.SolP(Gj).There exists µj = U µsuchthat µj .SolP(Gj), andtherefore µj .SolC(Mj).Since Mj = p.M, µj .SolC(p.M).µj .SolC(p), and µj .SolC(M).


Given the Plummer distribution of bodies that we use for our tests, the tree is highly irregular, which means that the subtrees on a given level have different loads.

spawning tasks on deeper levels of the tree does not help the performance because many tasks end up processing cubes with just a few bodies, while others process cubes with much larger number of bodies.


Despite the tight coupling to numbers, we see declaration .les use enums to describe .nite enumerations of string values.

we developed the access-path based interpretation of enums to allow for more liberal use of the enum construct when checking against a JavaScript library.


The lazy functional programming language Haskell 98 [18] does not support concurrency.

the extension Concurrent Haskell [19] was proposed.


BACKGROUND AND RELATED WORK Carrying out a (simple) sybil attack is generally quite straightforward in traditional distributed systems as opposed to OppNets.

research on the sybil attack focuses on devising effective detection/defense mechanisms, with little attention on how to best implement the attack.


Verifying compliance is usually a laborious manual process that, for cost reasons, cannot be performed for every version of an artifact.

having the ability to compare artifact versions can play a key role in reducing costs, since compliance verification can be restricted to the changed areas of the artifact.


Android and Java use different layouts to display components and widgets on screen.

a direct mapping of components and their corresponding layouts was impossible.


According to data from the Software Engineering Institute, human resources constitute an average of 70% of the costs in a software engineering project [4].

many problems that may lead a project to failure, for example, the high amount of software errors or unconformities, the variability of requirements, and others, are related with inefficacy in people management in the software development process, and could be improved by adopting adequate practices of team management [5].


The moderate correlation coefficient indicates that number of stakeholders is a good indicator of current issue lead time.

this result confirms the findings of other studies [16, 18, 19].


Increasing the MAX FAILURES and HELPING DELAY parameters reduces the numberof operations that require the slow path.Infact, when both parameters are set to 100, thefastwait-free queue steadily achieves performance similar to that of the MS-queue.

these results demonstrate that our wait-free design can achieve the performance and scalability of a lock-free algorithm.


For example, in our suite of 11 MapReduce benchmarks, the ratio of Map task processing times on Atom-based to Xeon-based nodes vary from 1.5:1 to 4.5:1.

despite skewing the data distribution, a signi.cant number of remote tasks will remain, leading to the performance issue outlined above (see Section 5.5).


In more detail with protocols share similar intent we mean that given the interaction protocols PW and PJ of W and J respectively, part of their behavior is complementary thus showing an interaction potentiality.

we expect to .nd, at a given level of abstraction, similarities in the structure of the protocol representations.


While variation points for the same feature may occur in different source .les and languages, they remain interlinked because they derive from a common source: the user selection.

this user selection in.uences both the .ne-grained variability within the source .les using the CPP, as well as the coarse-grained variability in the build system.


Node 6 is .nally executed after the two tasks have been synchronized.

two tasks, each one containing two child nodes, are executed in parallel, which decreases the overall execution time of the hierarchical node.


Compared with RGB model on the lighting issue, HSV model can achieve better results (Figure 4).

we use the HSV color space to build up a skin-color model to segment face from non-face region.


Enumerating and evaluating all of these scenarios is beyond the budget of this study.

we chose the queue-based communication scenario as shown in Figure 4, which is a relatively complex and highly stable communication approach.


This performance difference arises because the deterministic versions have less intra-task and inter-task locality.

we believe that determinism on demand, which leaves the choice between performance and determinism to the application user, is a reasonable design point.


Likewise, a conditional node passes the control to its unique subtree only if the condition associated with it is satis.ed.

navigation depends on the types of activity nodes, and the work.ow data.


The algorithm is intended to be used for su.ciently large L and Q, to be elaborated later in Section 5.

the k-th instance of NAB executes on a network corresponding to graph Gk(Vk, Ek), de.ned as follows: For the .rst instance, k = 1, and G1 = G.V1 = V and E1 = E.  The k-th instance of NAB occurs on graph Gk in the following sense: (i) all the fault-free nodes know the node and edge sets Vk and Ek, (ii) only the nodes corresponding to the vertices in Vk need to participate in the k-th instance of BB, and (iii) only the links corresponding to the edges in Ek are used for communication in the kth instance of NAB (communication received on other links is ignored).


Since the values of the iteration vectors from the different sections are far from each other, and the array element accessed by each array reference is determined by the value of the iteration vector, the addresses of the data elements accessed by the iterations that belong to the different sections tend to be far from each other.

data reuses are not likely to happen between two loop iterations from the different sections.


In addition, up to 50% of patients treated for alcohol dependence experience relapse in the 2 years following treatment, even after achieving abstinence [4].

this study proposes a phone-based suppor t system, called SoberDiar y, that helps alcohol-dependent patients maintain sobriety in their daily lives following completion of alcohol withdrawal treatment.


A miscon.guration in the .rewall policy can leave the network vulnerable to attack or deny legitimate users access to resources.

it is important that .rewalls be con.gured properly.


Navigation: Once the Presentation Units are de.ned, the navigation between them can be derived based on the temporal operators from the task model.

in most cases the navigation does not need to be customized itself.


Stories, characters, and events are still controlled by scripts that are written in C-like languages.

scripting the video game content usually requires a high level of programming knowledge.


matches the code that is generated from the direct dispatch idiom.

it is equally e.cient regarding memory footprint and performance.


This kind of study follow the systematic review guidelines, but as a result are reported the frequency of publications for categories within a proposed scheme.

the coverage of the research .eld can be analyzed and different facets of the scheme can be combined to answer more speci.c research questions.


If wecanarrange R2 the memory processors such that their number M becomes negligible compared to P when increasing R, the resulting algorithm meets this condition.

for a design with v P =T(R2), we maychoose M to be O(lgR), orO( R), or M = O(R), orM = O(R lgR), for example.


However, in this case our proofs would have to consider the possibility of the control-.ow going from any statement in a process to the schedule function, and from there to any other process.

in reasoning about a system call implementation we would end up having to reason explicitly about invariants and actions of both schedule and all other processes, making the reasoning unintuitive and, most likely, intractable.


They also are museum professionals and other experts such as historians, and archaeologists.

we do insist on knowledge organization system.


Feature interaction problems found in systems developed without careful architectural design are hard to analyze and solve because it is di.cult to see how behaviors of components are coordinated to create services, i.e., how control information .ows between components for services.

in order to improve quality of the product, re-engineering of the product had to be enforced at a later stage.


These invariants are appealing because they make the dependencies between their variables explicit.

it is simple in general to .nd a partial ordering for the propagation steps that guarantees that each pair (variable, invariant) is considered at most once.


The seed used to kick-start key generation is kept secret and is not stored on the sensor node after the .rst block is stored.

sensor nodes are only able to generate new keys; keys that have been used and discarded cannot be regenerated at the sensor node since the node does not know the seed used to kick-start the key generation.


2.3.1 Limitations GNU Classpath follows the Java standard library API which does not have a speci.cation.

it is not fully compatible with the Sun implementation.


Thus, the students themselves had to interface their programs to EasyAccept to enable the automatic execution of scripted tests, and no further adaptation was necessary.

the percentage of acceptance tests that passed could be directly verified.


The system has to react to such a situation and .nd somebody else who will take care of the situation.

the alert will get a new delegate which will receive a new noti.cation.


bound for W (t), we have that, -c1n P(S(t) > (.¯+ e)n) = P(W (t) > (.¯+ e)n) = e , for some constant c1 > 0.


Jalen is also capable of isolating selected classes or packages along measurements.

this allows measuring the energy consumption of software libraries without disturboing the Java Virtual Machine s (JVM) or the application s classes and methods.


In the case of dijkstra, the baseline code achieves excellent performance under extreme frequency scaling.

it is very dif.cult for the timing speculative optimizations to contribute additional performance gains.


But in AspectJ, a call to log() excludes the respective parameter evaluation.

any around advice would be executed after the expensive string concatenations.


Well, Haskell s construct for de.ning new types, the data declaration, introduces a type that is isomorphic to a sum of products.

if we know how to compress sums and products, we can compress elements of an arbitrary data type.


In order for a processing node to accommodate relocation of an arbitrary mesh entity the processing node must have knowledge of the complete mesh schema.

since the schema information is small and potentially required on every processing node it is exactly replicated on all processing nodes.


From a purely pragmatic perspective, we note that our concern is not with the internal machinations of a process, but the utility of its output.

while our current programming paradigm tolerates the GIGO mantra (garbage in, garbage out) natural systems spend considerable e.ort sanity checking and correlating often con.icting sources of information to make a best e.ort attempt at satisfactory output.


w(gpY 1 (p(v1 , ..., vn ))) source sorts.

we really are de.ning 3 put transformations: putting an A back to an E, back to a T , and back to an F .


On the other hand, he did not mention operations that were not supported by the languages he wasfamiliarwith.

itismorelikelythathisexpectations were the result of his experience, rather than the result of a basic observation about what programming languages should include.


The total number of 0s across row i is, where.


In contrast, a Figure 6: Streaming time as a function of d0, B = S = 20MB, br = 128kbps, vmax =5m/s, .-11 = .-21 = 30sec Figure 7: Minimum bu.er size as a function of S, .-1 .-1 d0 = 100m, br = 256kbps, vmax =5m/s, 1 = 2 = 30sec large bu.er size ensures that we can use the maximum possible bandwidth to stream the multimedia object if the link can last long enough.

we observe that determining the minimum bu.er size is very important for improving mobile streaming applications.


To measure the time overhead (inserted phase marks and core switches), instead of switching to a speci.c core, we switch to all cores allowing the stock Linux scheduler to handle scheduling.

the difference in runtime between the unmodi.ed binary and this instrumented binary shows the cost of running our phase marks and core switching at the predetermined points in the program.


This field, which is at the border of the software and hardware domain, is often outside the instructors' specialization, thus causing them to feel uncomfortable with the material they teach [3], Moreover, the increasing complexity of computer hardware & software systems makes them pedagogically inappropriate tools for instruction.

instructors have had to turn to simulators and visualization tools as teaching aids [12].


Change propagation generally applies if the code bases of the products are separated (e.g., di.erent branches or cloned products).

whenever a change propagation happens, Figure 2: Details of core asset evolution.


Due to delays in the network and processing delays at e and e', it is likely that e' will not ' receive the query until some time t> tiss.

similarly, e is unlikely ' to receive e' s response to his query until some time trcv > t. e cannot conclude that f was valid at either tiss or trcv ; he can only infer that f was valid at some time t where tiss = t = trcv ; we will discuss methods for .ne-tuning these types of inferences later in the paper.


Hence, difference analysis do not compare two di.erent versions of the model but, in fact, two di.erent states of the SECO captured within a single model.

special analysis techniques are required.


Now, if we consider the transition system having only non-redundant transitions, the ordinary notion of bisimilarity coincides with ~.sb.

in principle, we could remove all the redundant transitions and then check bisimilarity with a standard algorithm.


Instead, robustness requires situation and context dependent selection of available skills and system con.gurations at run-time.

at design-time the developer speci.es variation points and corridors in which the robot can make decisions and operate at run-time [31].


[24] also uses WPNs for con.guration processes, but they apply them as reference models for business processes.

their framework ensures soundness for con.gurable business processes while the veri.cation of the operational con.guration semantics itself is not considered.


This time is in accordance with the results presented in [7].

whenever our approach assigns a CR successfully, according to de.ned metric for accuracy, 10 minutes are added to the total time saved with automated assignments.


A null pointer indicates that the elements in the subobject have not been initialized by the application since the array has been created.

for each read access to a null subobject, JVM returns a pre-de.ned uninitialized value according to the type of the element.


3.2.4 Linking While producing generic machine code that can be used on different clients has its benefits, it can be costly because each individual client must link the machine code before executing it.

cS produces optimized machine code that clients can simply download, install, and execute without any modification.


of Test Cases Selected 80 70 60 50 40 30 20 The results of this study will guide our development of pro-10 .lers in the future.11 0 To perform this study, we used DejaVOO to select dangerous edges in P. We then used a data-.ow analysis that considers each method M, and determines whether some dangerous edge in M is reached on all paths from the entry point of M. If a dangerous edge is reached over all paths in M, all test cases that enter M will be selected by an edge-level version of Retest.

in this case, no further 11The development of a pro.ler for recording information at the edge level requires signi.cant e.ort, and the results of this study can help us decide whether this e.ort is worthwhile for regression test selection.


Furthermore, it is not possible to calculate an example to why an edit is a generalization or to determine the number of added or deleted products.

we base our solution on equivalent transformations.


They also felt that debugging transforms was different from debugging normal Java applications, as the inputs to transforms are typically more complex and have more elaborate syntax and semantics.

automated debugging support that is customized for such applications can be useful; our approach provides such support.


From the task graph in Figure 2, we conclude that Cmax =36 and dmin =6.


The problem our system solves is the latter; negative examples of ad hoc data sources are not available in practice.

effective theoretical algorithms for learning from both positive and negative examples such as RPNI (Oncina and Garcia 1992) are not applicable in our context.


However, a traditional approach models each component and link separately as a variation point in and of itself, each governed by its own redundant (often Boolean) clause to determine inclusion or exclusion.

the way in which an architect logically views and interprets a PLA, i.e., in terms of the features that determine differences among individual products, does not match the modeling constructs available to express those differences.


This event categorisation is usually a cumbersome and error-prone task, especially when timing is involved.

event categorisation should be offered to the programmer as a service by the underling system.


A delayed arrival might result in issuing an email to some other person or in cancelling a hotel reservation.

a strong motivation exists for having means to specify and/or request updates to (local or remote) Web sites and to propagate the updates over related Web resources.


Instead, for every artifact corresponding valid and adequate rationales must be given.

this means that curricula in software science require an orientation toward curricula of those sciences that have already identi.ed a strong impact of human factors.


During the execution of reverse ((:) 42 []) there is only one recursive call to reverse and its result is the constructor [] introduced in the .rst rule of reverse.

this constructor .ows to the case expression in the de.nition of (++).


We emphasized problems that educational designers can encounter when specifying learning situations for such AWBES.

we have proposed an approach for describing such learning situations together with the constraints that must satisfy that AWBES.


Stopping an aircraft abruptly in mid-.ight is not a viable fail-safe strategy.

high reliability requirements are mandated by system safety considerations, not just service requirements.


Converging types are decided based on the leading area.

it can be expected that the results of this study can give valuable chances to increase the understanding of converging technologies within the related institutions, corporations, and academics.


Note that channels may be closed, preventing further communications.

a select construct considers only its open channels, and terminates without choosing any branches when all of its channels are closed.


We also treat the collector s addOrigins as atomic.

these two steps are represented as single atomic building blocks, respectively M5 and C3, in Table 1.


A scheduling policy to limit these loops on few cores might not be the best method as running them on all the cores might still allow for a low power pro.le and lesser execution time.

the BB approach might miss a schedule that can give faster execution time and at a lower average power cost.


EXPERIMENTS ON NETLAG To evaluate the performance of an application as exactly as possible, it is crucial that the process of collecting data within the application does not in.uence the performance of the application.

we conducted experiments to study the overhead introduced by the data collection when using the Beaker component of Netlag.


However, at the same time, we faced problems when applying ESC/Java2 in situations where the resulting specification and corresponding implementation become considerably complex.

in the following sections, firstly, we show our overall experience of using ESC/Java2 in the context of the specifications and implementations given in Figure 4 and Figure 5.


978-3-9815370-2-4/DATE14/ c @2014 EDAA Recent work in multiprocessor scheduling has shown that partitioned scheduling typically has better schedulability than global scheduling for hard real-time systems [5].

in this paper we use the partitioned approach to schedule mixedcriticality systems.


In order to achieve the reconstruction speed necessaryforthetypicalmedicalwork.ow,thelevel of concurrency in the pipeline design is still not su.cient and .exible enough.

the software architecture of a reconstruction system has to be extended by including other possibilities of achieving concurrency.


The simulation results demonstrate that the block-level deduplication usually exhibits trivial superiority to the full-.le deduplication, as shown in Figure 5.

we have the following implication: For providers, in terms of deduplication granularity, supporting full-.le deduplication is basically suf.cient.


ABASISFORDSLDESIGN In past work, we demonstrated how separate concerns (e.g., layout and behaviour) within a single DSm could be isolated and mapped onto concern-speci.c lower level formalisms (e.g., Statecharts for behaviour), and later woven back together into complete artifacts [13].

our current claims 5 the semantics of high-level models is de.ned in terms of the well understood semantics of low-level programming languages.


that path is made up of edges, each of which comes from some trace, which means for each edge, there is a corresponding edge in M. there is a corresponding path .


In the list based on Church numbers this argument has type b, the result type of the list manipulation.

we do not pass the arguments nil and cons as arguments to the tail x in the de.nition for the constructor Cons.


CPUs, memory and hard disk), and they are not capable of handling very large spatial dataset.

we propose a MapReduce based algorithm to create contiguity spatial weights from big spatial data.


In this downfal of transformations, if changes are incorporated in one stage, al the subsequent stages must be reworked.

it is Kewo Requirements, Domain Analysis, Aspect Oriented Software Development, Crosscuttingconcerns, LEL  1.INTRODUCTION The development of software systems is a complex task.


However, the granularity is very different: viable services are much heavier than typical objects.

there is a trade-off between the strong guarantees and the limited composability that a service can offer.


The forerunner of interactive feature location is [4], in which, this problem is referred to as a concept assignment problem.

feature location is viewed as the process of assigning human-oriented concepts to program-oriented concepts.


Data is typically processed in a series of steps performed by possibly different tools requiring different data formats and types.

users frequently need to reformat or transform data.


Also, evolving projects may change their requirements regarding their variability descriptions.

a tool that checks for con.guration problems should be .exible enough to incorporate information about desired issues in order to deliver precise and useful results; it should also minimize the number of false positives and false negatives.


We model the watermark detection as the the Neyman-Pearson test in this work.

it is not necessary to specify the prior for the message M here.


Our approach, in contrast, shows how to produce norms that comply with our chosen metamodel [26].

our approach can greatly facilitate the above kinds of analyses.


We are thus guaranteed that if we compose an architecture model of a MSC specification with a LTS constraint of a simple negative scenario that is the result of a rejected implied scenario, then the constrained architecture model will continue to provide the specified behaviour of the positive part of the MSC specification and will not exhibit the behaviour of the rejected implied scenario.

we can compare the constrained architecture model and the trace model with respect to maximal trace equivalence to detect further implied scenarios.


We put a heavy load on a single grain by simulating a subscriber who follows many users.

we also added a short processing time of 10 milliseconds for every message...this.user s.grain.becomes.a.bottleneck,.since.it.can.process only a limited number of messages per second.


However, like .., type checking is not decidable for ZT expressions.

the implementation also includes an annotated version of ZT that supports syntax-directed type checking, an approach we have explored in previous work [34].


Correspondingly, the original data.ow along each control .ow path is basically maintained in the tree(s) as well.

the lifetimes in the tree(s) are more natural; the basic blocks with close data.ow relationship are putting close together, which avoids unnecessary data.ow transfer between them afterward, and also reduces spilling.


Whereas, usual impact analysis methodologies consider the revision phase as completed, thus presenting to the user the propagation of the completed adaptation to the existing system.

the process itself is moved from the .le repository back to the IDE supporting the system design; in this way, modi.cation analysis can be performed at higher levels of abstraction and are no longer limited to .le-or text-based reasoning.


Given a computed answer for p(xx), one can obtain a computed answer for p(xy)via renaming.

we reserve a set of special variables .={.1, ··· ,.n}where n is the maximum arity of the predicates in .and de.ne the meaning of a predicate p of arity m as the set of computed answers for p(.1, ··· ,.m).We further denote the sequence of arguments in p(.1, ··· ,.m)as .(p).


Emerging phenomena that arise from the complete set of interactions cannot always be observed by all individuals.

an entity applies mostly limited, local information when deciding what actions to execute next.


a) The PFR of NTFD/-E Message delay and messages loss cause the false detection of NTFD-E. We already considered these two factors in TD_NTFD-E.

the PFR of NTFD-E can be calculated by: PFRNTFD-E = pc(T)* TD_NTFD-E /T.


We assume that n2 is at a more advanced position compared to n1 such that the piece set of n2 forms a superset of that at n1.

even though n2 canupload thepieceneededby n1 it cannot receive anything in return as n1 does not have the piece needed by n2.


In MayKill,we replace LocAlias with MustLocAlias, so fewer expressions are removed from the May set.

the May set is a superset of the concrete value alias set.


Connectivity Metrics Network connectivity information, collected from every node in the network, helps Sympathy detect and localize routing failures.

sympathy collects every node s current RO U T I N G TA B L E its sink, associated next hop, and path quality and N E I G H B O R L I S T, which lists all of its neighbors, whether involved in routing or not.


By preprocessing the code of Listing 3 using this con.guration, developers close a bracket at Line 8 without open its correspondent bracket at Line 3.

we generate an invalid program that does not compile.


SU G G E S T I O N S Unsupported criticism is dif.cult to take and destructive criticism not only has the possibility of making the author F O R uncomfortable, but provides no outlet for learning.

iM P ROV E M E N T [Coplien 1997] Provide constructive feedback to the author; that is, offer no criticism unless it is accompanied by a wellconsidered, actionable suggestion for improvement.


bigger heap translates to more time for objects to die), heap resizing policy can also play an important role.


Hence, direct preemptions are not enough for computing the total overlap cost related to a given task, the executions of the other tasks must also be taken into account.

in order to compute the context switches costs, it is required to enumerate the patterns of preemption occurring along the execution of the system.


As a result, for all i, element (i, Ln/2J + 1) of the matrix gives an estimate of the RTT of a majority of processes to process i. Algorithm 1 Delay-aware leader election.

even if the leader changes after GST, this happens 1: Initialization: 2: .p : localrttp[p] .8 3: rp .


However, all inter-node communication is required to be described by the programmer using, for example, MPI, which is a librarybased language.


Hence, both features are always present at the same time in the generated DSPL.

an adaptation rule that requires LOG and excludes TRANSACTION is invalid in this DSPL.


In addition, using JSONP allows the remote site to inject any JavaScript code into the original website instead of expected clean data wrapped into the specified callback.

jSONP should not be used, if the remote site is untrustworthy.


Recall that Cd m is the span of functions w : Dm .

f of the form w = m g1(X1) ··· gm(Xm), withj=1 deg(gj) = d. it su.ces to show that for w of this form, w|D!


Interestingly, this technique has a more signi.cant impact on functions with larger default search spaces.

summing up the search space sizes over all 107 functions, we .nd that the number of total distinct function instances reduces by 37.4% compared to the default.


It follows that in E(MI) process a does not take any steps and in particular does not top-write in any of the rounds iI,iI +1,...,j.

from the de.nition of function erase, it follows that MI equals N in rows iI,iI +1,...,j, which completes the proof of (d2).


By monitoring only taken branches, we can form longer traces than if we had monitored all branches since not-taken branch information can easily be reconstructed by scanning the instructions between the last branch target and the next taken branch instruction.

a reconstructed path can have more than four basic blocks.


For some programs, such as 2D convolution, this was not possible.

the performance results reported here are likely overly pessimistic.


Let us further assume there is an edge between a call site c and DUMMY in G. In other words, the function called at c may not return.

there exist a program path from t j to IP D( s)m, the calling contexts of the path follows the below pattern: CC(t j ) .


The Dhruv system [1, 2] aims to assist the bug resolution process by recommending relevant information during bug inspection.

dhruv is integrated in a web-based bug tracking system where it displays recommendations in a sidebar.


Finally, a singleton type, such as x.type, is only inhabited by the object referenced by x.


Sj are available, while the other services in C are unavailable.

aj is the multiplication of the availability of each service aj,k multiplied by the probabilities uj,l for the other services in Tj .C Sj to be unavailable.


It has been shown that workloads in data centers tend to be diverse [14], containing a mix of jobs that are CPUintensive, memory-intensive, or I/O intensive [15, 16].

ef.cient scheduling in datacenters requires taking multiple resource types into account.


Also, the adaptor A is constructed e.ciently with the definition of protocol tree.

the performance of the complete method is quadratic in the number of nodes for protocols containingparallelism andloops with same multiplicity.


2.1 Input Traces LM is agnostic to the language the program under analysis is written in.

engineers may use existing instrumentation tools to collect traces, e.g., AspectJ for Java, AspectC for C, Valgrind for binary C, JRAT for Java byte code etc.


Usually the channel availability is not common in MAC protocols.

the probability of a channel being common to nodes is comparatively small.


However, the set of classes untrusted domains (e.g., mobile objects) are allowed to access is limited and known to the J-SEAL2 kernel.

the kernel accounts for the classes using an approximation, which is proportional to the size of the class-.les.


MDE still incurs a tremendous amount of image distortion, owing to its inability to fully consider the relation between predicted pixel and its neighboring pixel.

this work presents a novel reversible data hiding scheme based on a predicted error.


For example, according to Table 2, missing single assignment takes up 9.8% of the cases.

we randomly selected 98 mutants from those versions with such fault.


Although, from a theoretical point of view, De.nition 3 leads to a correct dependency pairs approach for OS-TRSs (see Theorem 1 below), some useless pairs could be generated (see the examples below).

it makes sense to use a combination of (unsorted) syntatic checking and a reducibility test by narrowing.


5.3 Timing Covert Channel (Example 3) The third scenario describes a covert timing channel that occurs when a Low subject executes two GetClock statements (gc1 & gc2), and between them a High subject prevents the Low subject from executing, through execution of a Read_dev/Write_dev or direct file operation (rw state in the text).

when the Low subject next runs, it can examine the clock to detect this interference with its access to the CPU; these channels are thus often called CPU channels.


Indeed, a key .nding from the Computer Supported Cooperative Work (CSCW) research community is that tools that ignore emergent work practices and social aspects of a tool s use frequently fail (for examples, see [16]).

a challenge for the software engineering tool community is to develop tools that support both aspects.


However, the physical clocks there were used as a mechanism to incorporate out-of-band causality beyond the causality propagated through message exchange.

those clocks required a tight enough synchronization bound to subsume any such causality.


1Note that in this paper we do not compare our results to the ones from [8], because [8] essentially implements the very same analyses, however speci.c to tracematches only.

if our dependent-advise-based optimizations, applied to tracematches, were compared to the tracematchspeci.c ones in [8] on equal machines and JVMs, both would yield the very same result.


Furthermore, the initialize() method is executed to instantiate all the periodic event handlers that will be periodically executed during the mission.

the infrastructure instantiates the CollisionDetectorHandler class and creates a corresponding private memory -the size of the private memory is given in the constructor of the handler.


We observe that there is no data dependence between any innermost loops.

in each outermost loop, the address generator in Figure 6 can keep on feeding reading addresses to the memory without any pipeline bubble.


VISION We consider that expressing and using a company-speci.c common terminology is central for enabling the use of architecture reconstruction approaches in the industry.

the architects should be able to adjust the output of the reconstruction tools (expressed in an intermediate terminology after having been extracted via technology-speci.c adapters that address the problem of heterogeneity) and to make it correspond to the architecture meta-model of their interest.


2i+12£-1 1=i<£ We upper-bound the sum in the last line by observing that each term is at most 1, and also the i-th term is at most a 1 - 1 - k = k , by the known inequality (1 - E)k = 2i+1 2i+1 1 - kE.

kk f(k) = 21+2+ 2i+1 2£-1 1=i<log k log k=i<£ kk = 2(log k +1)+2 + = 2 log k +6, 2log k 2£-1 since f = plog nl= log k. For f(k) = 2 log k + 6, we have .f-1(k)= O(log * k).


While our work is an attempt to advance the work of Bierhoff and Aldrich (2007) to the world of concurrent software, we .rst wanted to study the problems of concurrency in relative isolation.

we have not included many of the more advanced features of that system into the work presented here.


A critical concern with processing ontologies, in particular on resource constraint mobile devices, is the number of defined classes, properties and relationships.

the MUSIC Ontology is divided into a two-level hierarchy.


Although bandwidth and access will continue to improve over time, the service and transfer to device-back latency is unlikely to get improved.

the main need in such a case is the deployment of a resource migration and offloading approach that aims to release an aggravated terminal in data center rack, and migrate according to certain parameterized requirements the resources to other racks based on the minimized service and processing delay, respectively.


More importantly, existing approaches fail to specify the impact of aspect weavingontheQoSofanexistingapplication.

wearguethat planning-based adaptation middlewarecanbene.ttoexistingAOP approaches by providing a run-time support for thedynamicselection of aspects.


When user1 and user2 edit a page at the same time, Collectra sends the same obsel twice to the kTBS.


In the remainder of this section, the generated code is described.

we introduce the evaluation of the system s components.


Obviously, even if a correlation candidate has many supporters, a low con.dence would make the correlation not trustworthy.

mUVI uses a threshold MinCon.dence to prune out correlation candidates with too low con.dence.


Consider the following: aspect X extends StaticRel {}; aspect Y extends StaticRel {}; The concrete aspect X results in .elds Fwd.fwd and Bwd.bwd being de.ned for classes Aand Brespectively.

likewise, Yresults in Fwd.fwd and Bwd.bwd being de.ned for B and C. the effect of extending StaticRel depends very much on the actual type parameters supplied.


The techniques proposed in those studies mainly prohibit changes of target programs when the change causes pointcut mismatch.

when the programmer has to change the target program against the interface, it is the  Figure 6: Evolution of the connection classes and the noti.cation concerns Table 1: The result of previous versions of aspect application to later versions programmer s responsibility to .x the interface and aspect de.nitions.


Note that the 802.11 MAC in infrastructure mode also requires that stations do not communicate directly, but forward all packets through the access point.

when calculating the load on our network, we must factor in the extra work done by the AP.


To begin, let us notice that, by de.nition, [pDis ' letrec apply in p .

the con.guration 0/ /[pDreduces, in one ' step, to apply /p .


Similarly, the instrumented string returned by getName, TCH.SomeClass is translated to SomeClass .

if the returned string is compared to a hardcoded class name string, the result of the comparison will be correct because the hardcoded names remain in non-TCH form, despite the TCH transformations.


In this manner, any other distributed middleware client can discover, bind and communicate with the DPWS-hosted services.

the proposed method provides any client with adaptive interoperability.


Because compilation time is added to execution time, the savings in execution time must outweigh the compilation overhead.

all JITs emphasize compilation speed at the expense of complex optimizations.


We consider a structure .eld to be owned if that .eld will be .nalized within the context of a .nalizer function.

ownership of an object is transferred from a caller when another object assumes responsibility for .nalizing it (i.e., it is stored into a .eld that will be .nalized).


The primary purpose of this distinction is to allow a message s information content to be partitioned according to likely roles.

an intermediary that only needs routing information would examine only the routing part.


Since aj s double in each iteration, aj (t) >n · a * for t := 3log n. Now recall from the initialization phase that a * = maxj mini(fi + cij )/n.

a(t) will exceed mini(fi + j cij ), which means that client j, all by itself, is paying for more than the amount needed to open facility ,where i * i * is argmini(fi + cij ).


We only search for NDSeq executions for which the control.ow path outside if(true*) branches is the same as in the parallel execution.

we might miss an equivalent NDSeq path, and falsely report lack of con.ict-serializability.


From the point of view of the running Java application, the network connection is not visible, so the application executes as if it was fully loaded on the mobile device.

all application data .les are stored on the client as well.


Without loss of generality, we assume array A is smaller than array B.

the arrays B and C are partitioned equally among the P processors whereas A is replicated on all processors.


During the period of (t6, t7), tM is blocked by tL while blocking tH.

tH is indirectly blocked by tL in a transitive manner.


Typically, a unidirectional association is mapped to an instance .eld declared in the source class, and a bidirectional association is mapped to a pair of instance .elds, each of which is declared in one class participating in the association [18].

a runtime link may represent a design-level unidirectional association or half (one direction) of a bidirectional association.


While this is not a problem in itself, the transformation should be performed only once since it conceptually modi.es the data in place.

the (DEREF) rule evaluates the contents of the reference and then writes back the result before proceeding.


The results revealed ample opportunities for environments to better support end-user programming as a design activity.

our work makes three contributions: 1) the methodology of applying a theory-based design perspective to programming, 2) evidence of the usefulness of using this approach through insights gained, and 3) the insights themselves into end-user programmers problem-solving attempts, with implications for design of end-user programming environments for mashups.


In fact, the end of a computation is reached, in a Web application, when some result is displayed to the user, but no intrinsic notion of termination for a navigation session exists.

dynamic pages whose content depend on the user input are good candidates for ending meaningful computations.


In step 7, by .nding the minimum cut, the total number of computations of X arising from the insertions across all the edges of the cut is minimized.

the insertions at and only at all the edges of the minimum cut is the computationally optimal set of insertions.


This results in an even division of a workload across whatever subset of nodes is powered-on.

performance can be scaled up in an ideally power-proportional manner, at the .ne granularity of the throughput of one node at a time, to a maximum of roughly e r-1 p nodes, where r is the number ofreplicas stored for that data.


that by uni.cation, methods captured from the most speci.c pattern will de.nitely exist in UnitPair as well.

it is statically safe to call methods in the UnitPair instance in this manner.


In the process of propagating/updating registry and witness tables, the social network may change again.

it is helpful to consider it as a decentralized, background stabilization process.


Although Figure 2(b) shows that leveraging FoFs increases the hit rate slightly, the di.erence is not very high.

we decided to not include FoFs in our algorithm given the additional overhead of caching FoF objects.


)time deterministic algorithm (see Appendix A).

we need only prove our lower bound for deterministic algorithms.


The underlying assumption of existing unit test frameworks is that the unit under test has a deterministic behavior.

tests can assume an initial state when creating an instance of that particular class.


Hotpath focuses on traces starting at loop headers and does not compile traces not in loops.

it does not approach trace linking as we do, but rather merges traces that originate from side exits leading back to loop headers, allowing it to compile loop nests.


Equivalence partitioning [3, 25] is a testing technique in which the input domain of the program is divided into partitions (also called equivalence classes ) in which the program is expected to process the set of data input in an equivalent way.

only an input value of each partition is needed to evaluate the behaviour of the program in that partition.


Depending on how the arrays A and D are laid in the main memory, there can be cache conflicts (due to limited associativity).

each time a process (of Prog1 or Prog2) is scheduled, it would have only little opportunity (if any at all) for data reuse.


In a full-associative cache, datafrom any memorylocation canbe storedin anylocation(cacheline)inthe cache.

only capacity misses canoccur accessestodatathatisnotinthe cache whenthecacheisfull.Lastlevel caches areusuallynotfully associative for technological limitations they would be too expensive and take too muchpower[20].


In particular, the customized work.ow consists of three key analysis routines as shown in Figure 2.

in order to better distinguish reactants and products, the raw image for .ame tracking that is taken by experiment cameras during the experiment needs to be median-.ltered; the image is then binarized with the threshold intensity selected using Otsu s method [2]; 0 is used to represent the reactants and 1 for the products [18].


Programming at this level of detail would be too cumbersome for the programmer.

partial type inference techniques should be used so that suf.cient type and coercion information can be reconstructed, but new approaches may be needed.


In applying both frequency-based and temporal-based data layout to various applications, we .nd that the temporal-based algorithm consistently outperforms the frequency-based one.

we will present only the temporal-based results later in Section 5.


Such a chain reaction results in cascading tripping that can quickly deteriorate system performance and cause large-scale blackouts within several minutes down to sub-second [4], [15].

the detection and immediate interpretation of critical events would be very helpful.


[15] .nd that the e.ectiveness of animation is strongly predicted by node speed and target separation.

there exists a bottleneck stemming from the analyst s cognitive load, as the analyst must remember patterns over a large time span or time points must be traversed quickly increasing node speed.


One of the most important properties of context-aware applications is that they change their behavior at runtime.

we need to identify when a variation of behavior switches to another one.


(3) Due to the proposed implementation template, the implementation of the service layer and the service scenarios are well separated.

it is easy for the user to add or modify the integrated service scenarios.


On the other hand, for a special input with Nx = Ny, we can have the same memory area for A2A source and destination data in each communication tile, by generating the y-z-x layout (as opposed to z-y-x)after A2A and Unpack.

for the case of Nx = Ny, Transpose rearranges the memory layout from x-y-z to x-z-y, so that we can improve the overall 3-D FFT performance.


For these subjects, considering contexts does not seem to improve the precision of Andersen s algorithm.

we do not show their results in the .gure.


when the shockwave front hits microphone M1) the bullet is at position B1, and similarly, at tsw2, the bullet is at point B2.

the bullet, traveling at speed v, covers the |B1B2|distance in .t time.


Signi.cantly, pi cannot tell what p1-i saw when it checked lock.

to make sure that p1-i does not get stuck waitingfor ahandshake thatis never reciprocated, pi releases lock, allowing p1-i tofall through the secondline(ifithas notdone so already).


The main result of this section is that given an unannotated Proteus program (no abst or cont or update expressions), we can statically infer all of the program points that are con-free with respect to all types in the program, and insert update there.

we eliminate the need for conFree[ - ]2 and we make the update behavior of the program easier to reason about, since many acceptable update points are known statically.


First, the lobby server h2master.stre ampowered.com of Counter-Strike:Source returned the largest number of IPs during our experiments.

we use this lobby server throughout our experiments.


The natural conclusion is that CORBA clients can achieve much better performance by grouping multiple operations within single transaction.

transaction management should be carefully designed in order to reduce the negative impact of transactions handling and to boost the CORBA/ODB system's performance.


To avoid interfering with a VEE s code generation and code cache management mechanisms, Dimension uses the probe-based instrumentation technique, replacing a program s binary instructions with jumps to invoke the instrumentation code [11].

a VEE needs to provide the location of both the source and target code to Dimension, and Dimension then can analyze the instructions and make instrumentation decisions according to an instrumentation specification.


Observe that if a subsequence x is frequently occurring, all subsequences of x also occur at least as frequently as x.

we consider only maximal subsequences, i.e., it is the case that every sequence(si)in S is not a subsequence of any other sequence present in S. For example, if the set of sequences is given by {(a .


t3){3,8}, unsatis.ability is detected at (t5 = Bool){5,2,8}.


Ajax fails on many moderate-sized programs, and its operation is signi.cantly slowed by the need to re-analyze large parts of the Java standard libraries.

we were unable to fairly compare the performance of Lackwit and Ajax to that of Dyn-CompB and DynCompJ.


This is because, without any knowledge about threads and objects involved in a potential deadlock cycle, DEADLOCKFUZZER will pause any thread that reaches line 16.

if the third thread pauses before line 16, then the second thread will not be able to acquire lock o2 at line15 and it will be blocked.


For performance, [2] presented how to automatically include performance re.nements for implementation details such as middleware con.guration in the software model.

the di.erent combinations of con.gurations could be explored as degrees of freedom.


These servlets must necessarily be stored in a data structure mapping each URL to the appropriate servlet, thus requiring uniform treatment of servlet extensions.

we observe that the full functionality of the servlet framework cannot be realized in a system without using service abstractions.


For example, the target(s) of indirect transfers of control such as jumps on registers are sometimes hard to analyse statically.

a fall-back mechanism is commonly used with a statically translated program, in the form of an interpreter.


The semantics is deterministic because the branch to explore in every choice is prede.ned by the initial con.guration.

the algorithm can execute the semantics several times to iteratively explore all branches and hence, generate the whole CSCFG.


GEOGRAPHICAL INFORMATION SYSTEM (GIS) With added responsibilities of the District Managers it becomes difficult to study extensive analytical reports for decision making.

data projections are being used in support of preliminary identifications for assessments, deployments and resource managements, for which maps are a key component.


Second, this system was produced and maintained by a di.erent corporation from the one responsible for the three earlier systems.

the development environment, the prevailing corporate culture, and the development paradigms are all likely to di.er from those of the earlier systems, providing a good test for the adaptability of the prediction models to a wider variety of systems, and helping to convince potential users of their value.


Likewise, it is possible that categories of physical objects are used to deduce functionality about category members.

no simple distinction between categories and functionality of those can be made.


Thus, product lines with multiple base modules, that may not correspond to valid products, are possible.

pure DOP is a true generalization of FOP (cf.


With each iteration, sm or jm or the mapping relation (represented as S)in the algorithm may change.

we repeat our algorithm till S, sm, and jm do not change anymore.


All internal representations and computations are based on planar arrangements.

to enable algebraic polygons we use the algebraic traits presented in Section 3.1.


DoctorMe illustrates the potential for combining creative tools while enhancing public health through crowdsourced data.

the two main objectives of DoctorMe s participatory surveillance approach are; (a) to provide users personalised health care recommendations through a feedback loop based on the reported symptoms, which consequently contributes to improved personal health and potentially decreases the costs of medical care, and (b) to utilise the captured data on an institutional level to track public health trends and identify potential disease outbreaks, which may be analysed by the Thai Bureau of Epidemiology, local hospitals or veterinarians.


Indeed, these events have a key role in the overall execution and re.ect the programming guidelines followed during the development.

the main contribution of this article is a novel approach for the design of interactive debuggers, which describes the key functionalities that should be provided to allow an e.cient debugging of data.ow applications.


We believe that the history of software components in capital markets is not the sole indicator of s, and, it is possible to look in the change patterns of modules throughout their lifetime in the light of several other environment parameters like users, external services, socio-technical implications etc.

we intend to formulate indirect measurements of s in terms of the environment parameters that are speci.c to the particular examples we choose to collect historical information.


More speci.cally, we measured that sequential blueprint pro.ling introduces an average overhead of factor 12.31, while a naïve parallel implementation introduces an average overhead of factor 190 on standard benchmarks.

to overcome the parallelization overheads and to improve performance, we make the parallelized tasks coarse-grained by aggregating the invocations to these methods in a thread-localbuffer and processing them altogether when thisbuffer is full.


smartSockets uses a heuristic that sorts the target addresses in relation to the addresses that are available locally.


At last, details of PCIe switch are encapsulated in the new kernel mode and it only provides interfaces to Atap.

any similar low-level communication media can replace it by providing the same interfaces.


Overall, the challenges regarding the alignment BPs and enterprise mashups include the re.nement of requirements, the discovery and composition of interactive mashups components, as well as the integration of human activities in work.ows.

we present a continuous model-driven development method that aims to .ll the gap between taskoriented problem space and service-oriented solution space by making use of task-modeling and UI mashup concepts.


RELATED WORK The issue of broken links in websites is well-known to the researchers and practitioners for long.

there are many tools available that are able to detect and report if there exists a broken link in a website [2, 5, 6].


The MAMView represents at each tree level: circles for the nodes region, dots for objects, bigger dots for the representatives, line segments for connections between the object and the representative node that its bellows, and tags for ob jects identi.cations (IDs).

the user can directly associate the visual element illustration to each MAM element.


After a command is requested, its avatar behaviour is similar to a NPC.

mobile player actions might be done without needing a permanent connection or immediate feedback to its commands.


In fact, since, for every task, a candidate is guaranteed to exist, we expect EXH to return 100% opr.

if correct, DANS should also have 100% opr value.


Face validation in this phase of model development consists of at least three methodological elements executed by potentially di.erent human experts: Animation Assessment A human expert assesses the animation of the overall simulated system (or of parts of it) whether the simulated system appears to behave like the original system.

the animation must be on the appropriate level of detail and display all relevant dynamic aspects of the elements in a way that they are easily detectable by a human.


In contrast to SMT-solving, the aim of SPL-solving is to (preferably) onlyevaluateperformance predicates necessary for deciding the satis.ability of a formula (recall evaluation skeleton from De.nition 9).

while checking the feasibility of a skeleton valuation, we identify the satis.ability-irrelevant set with respect to this valuation and consider only the relevant variables.


However, this detection is limited by the lack of scalable andprecise reference/heap modeling(a well-knownde.ciency of static analyses), re.ection, multiple threads, scalability for large programs, etc.

inpractice,identi.cationof memory leaksis more often attempted withdynamic analyses[23,4,16,17,40,5, 36,6,25].


However, the ability to use all six functional units will help spread the power dissipation across all components and reduce the peak power density.

the challenge is to strike a balance between the ability to exploit the low power modes and making the power dissipation on different units uniform.


This, in turn, leads to higher false alarm rates.

we need to achieve a prediction performance that is as near to (1,0) in terms of (pd,pf) rates as possible.


Graph models can be walked, either randomly or deterministically, but can not be traversed exhaustively because of the large number of possible traversals.

it is common to traverse all paths of the graph up to a speci.ed length [14].