These analysis tools then perform the exploration and propagate the results back to the original model.

as the analysis tools are usually used as black boxes when exploring the design space, they cannot be easily extended to support conceptually novel exploration algorithms (e.g., NSGA-II).


We di.erentiate a dead genealogy from an alive genealogy because the age of a dead genealogy provides information about how long clones stayed in the system before they disappeared.

for an alive genealogy, we cannot tell how long its clones will survive because they are still evolving.


7 The terms "Java Virtual Machine" and "JVM" mean a Virtual Machine for the JavaTM platform.

8 previous work on the Self project has gone a long way towards making it possible for VMs to optimize code written in that kind of style (see [10], [7], [11], [9], [5], [3] and [6]).


[9] describes a high-level pointcut language that allows for clearer speci.cation of semantic properties; they also aim to limit the restrictions of syntax-based pointcut descriptions.

their pointcut language is still tied to the host language model and therefore cannot capture metaproperties, although the technique could likely be extended.


Web services operate under the luxury of being relatively stable, with static information such as its location, resource availability, etc.

in pervasive computing, multimedia needs to be made available to users under a variety of scenarios, in the face of dynamisms in location, resource availability and such important factors.


In practice, this functionality requires very simple logic.

it requires three memory accesses: (1) The .rst access .nds the line is redirected, and (2) the second access goes to the redirection table, and (3) the third access reads or writes the redirected line.


When the application logic is de.ned, the graphic designer can starts working on the creation of graphics.

the framework approach also has some weakness for the interactive multimedia application development.


Synergy is able to prove this program correct in O(n) iterations by re.ning each abstract state with the predicate (lock.state==L).

dart requires O(2n)test cases in order to cover all control paths of the program.


Executing arti.cial benchmarks that make very heavy use of type passing and/or marshalling can be from 2 to 12 times slower.

compilation is signi.cantly slower than the OCaml ocamlc.


Other models may also fit our observations well.

the models presented here are simple requiring only two parameters that are straightforward to estimate: a defect density and a rate of decay in the discovery of defects.


Ensuring that all references are removed where an observer may be referenced from multiple observables can be a non-trivial operation.


The new de.nition of the option combinator isn t any simpler than the old de.nition.

there is an important qualitative difference between the two de.nitions.


Note that the speeds for jobs in such kind of feasible intervals might be scaled below the critical speed by reapplying VSLP within the current feasible interval (line 15).

its energy consumption will be lower than simply scaling the job speeds to scrit and shut down the processor, as already shown in Figure 1(b).


There are a few drawbacks with this simplistic approach (such as the the semi busy-wait loop, and the fact that the sender must cache everything it has sent), and more intricate schemes are certainly possible.

it does illustrate our point, and in Fig.


On the other hand, s2 only correlate with s1 arrived before ts.


One solution is architectural support such as word level Full-Empty Bits on Cray XMT [2] and SSB on IBM Cyclops64 [24].

such special architectural features are not available on commercial multi-core architectures for general-purposes.


Expert knowledge of common mistake patterns is necessarily incomplete, since everyone makes different kinds of errors.

sEMINAL does not require exhaustive knowledge to be useful, and it easily supports incremental improvements via the de.nition of new modi.cations.


In other words, if two test suites achieve the same coverage at the bytecode level, then these two test suites also achieve the same coverage at the source code level.

if two test suites achieve the same coverage at the source code level, these two test suites may achieve different coverage at the bytecode level.


In [9], it has been shown that the moments of the total error can be made independent of the system input signal and of one another by carefully choosing the distribution of the random error.

in ADC, the distribution of the random error is not known and cannot be controlled.


It might seem strange that we .rst generate chords for every melody note, and then remove some, while we could directly generate chords only for the notes we are interested in.

this is more modular; our current mechanism for removing leap chords is rather simplistic, but a more advanced implementation could take into account the surrounding chords proposed for melody notes that do not get their own chord, for example.


Error-resilient program transformations has been well studied.

all the existing works focus on approximating different components such as procedure approximation, input data approximation, control-.ow based approximation etc.


It should be noted that when an AsyncObjectEventHandler is associated with an AsyncLongEvent, the long payload could theoretically be boxed passed as a Long object.

this would introduce an allocation for each occurrence of the event and unnecessary complications with memory areas.


= 2 to the fdint store, the domain of Z changes.

no guard mentions Z and therefore there is no delayed goal that wakes when Z s domain changes.


According to our current work of analyzing characteristics of SOA implementation, these four dimensions that are Structure, Environment, Business and Resource can reflect the most 12 influential complexity aspects of SOA implementation.

the identification of complexity dimensions tries to avoid dealing with the excessively detailed and trivial issues.


He found that a team with high UAI waits until the project is about to start for up-front planning.

low UAI teams have to know exactly when the planning is finished.


Therefore no new predicted target can be added onto the chain after it is generated.

our approach incrementally builds the chain while the program is running and thus we can insert newly seen targets onto the chain in any order (e.g., Pin can put a new target either at the front or the end of the chain).


In contrast to SVTe, the technique proposed in [3] can also handle queries with aggregate operators.

some of its implementation limitations, which may avoid generating additional tuples for tables referenced multiple times in a query, affect the completeness of the technique defined in [3]: data generation may fail even though a (minimal) database returning the query result exists.


The tool chain which has been established during the last eight years included modeling in UML, exporting the modes to XML and generating Java code from the XML.

the models grew so large that the UML tool needed up to an hour to load the largest module.


Regardless of whether optional feature Response time of status update < 3s is selected, the status update function will always have a response time, and that response time may even accidentally be less than three seconds.

it is much easier to say when functionality is present or not present in the product.


Overtwenty majorstructuralindiceshavebeenproposed, including DataGuides [4], A[k]-index [6], and APEX [2].

it is not clear how these indices fare when directly compared to each other.


Lastly, Problem 3 is related to techniques for merging and re.ning behavioral models of di.erent viewpoints (e.g., [15, 3]).

these techniques provide no support for incorporating requirements that relate to di.erent parts of the system (e.g., a subsystem and a component in the subsystem).


RELATED WORK Adaptive middleware has been an active area of research in recent years.

much of this work focuses on the management of variable computational and network resources [6, 11] rather than focusing on adapting to changes in service-level requirements as described in this paper.


In Uniform Decomposition (UD) scheme, the server caches are controlled by the feedback controller described earlier.

it contrasts with MSQoS in that it does not have an adaptive QoS decomposition scheme.


For example, we obtain isomorphic graphs if we swap the identity of some nodes in the left DAG in Figure 3, say put DAGNode2 in children[0] and DAGNode1 Figure 3: Two DAGs of four that Korat generates for threenodes; the left DAG shows an entire visualization window with several customization options children[1].

the four graphs (two of which are shown) are themselves all non-isomorphic as they have different shapes.


Leak pruning is less tolerant of errors because it must throw an error if it makes a mistake.

it bounds memory usage, making it suitable when disk space runs out or no disk is available, e.g., in embedded systems.


Finally, Commuter provides a rich set of symbolic data types, including lists and maps, by taking advantage of Z3 s extended support for arrays [12].

it supports only Python programs explicitly written against its API and does not handle native functions.


The mechanism we use to control disk bandwidth is also based on a networking technique: token bucket .lters [10], which were designed for network .ow control.

unlike network bandwidth, the available disk bandwidth .uctuates due to variations in seek times for different disk requests, complicating its management.


The second stage makes its analysis di.cult,because the di.erent blocks are no longer independent.

if we pretend that the di.erent blocks are indeed independent we can apply a similar analysis to that v in Theorem 5.


When writing trace monitors for runtime veri.cation concerns, a successful match indicates that the program misbehaved, and so in an ideal case one might hope that a static analysis could remove all instrumentation, proving the program correct with respect to the given property.

when viewing trace monitors as an extension of pointcuts in an aspect-oriented setting, they typically contribute an essential part of the system s functionality our OBSERVER example is just such a case.


Although a network level solution may be more efficient, the overlay network does not require modifications to underlying network hardware and protocols.


The former goal is achieved by deleting largely unused .les and rerunning the jobs that created them when needed.

no time bound is provided to retrieve deleted data.


The code in this advice (Lines 6, 7, 8) is executed instead of the actual code defined at the join point.

line 8 continues with a proceed that permits the execution to continue from the original join point.


Implementing strongly consistent transactional synchronization can be achieved by centrally serializing the requests at a single master controller or using state-machine replication.

we believe such heavy-weight solutions are not required, since weakly consistent policy composition is good enough for many cases.


In ADSM, the compiler can use TLB/MMU mechanisms to detect remote- accesses dynamically, thereby eliminating inspector [22, 32] over- heads found in the message-passing system.

the run-time system can execute compiler-inserted routines (like ex- ecutor) for shared-write-accesses.


We could choose to implement the semantics of expression evaluation entirely within the eval method of the above expander, analogous to the code in Figure 2.

expanders support a better solution through expander overriding, as shown in Figure 4.


With this research goal, one might imagine the two sub.elds of HCI and PL share more past research than they do.

little work has been doneattheintersection ofparallelprogramming and usability, andthe smallbodyof researchthatdoes existinthis area is mostlyinconclusive[Luf09,HC09,SSE96,ESEG+06].


With this signature it is straightforward to port the free monad transformer implementation to Prolog (see Figure 3).

this meta-interpreter requires us to reify all of the syntax in Prolog which we are interested in.


Middle relays are mostly useful to increase the fraction of killed circuits.

as seen with the 2:1 (entry:exit) distribution, the adversary is also able to achieve a high fraction of killed circuits without including any middle relays in the distribution, and therefore sacri.cing important bandwidth for relays that are potentially not able to either serve as entry nor exit.


That is, there was no change in the authorship of that code from one time snapshot to another.

part B of Figures 6 and 7 reveal how the authorship of code changes over time.


Hobbes slow-down factors for SPEC CPU2000 integer programs were in the range 30 187x.

hobbes used a built-from-scratch binary interpreter rather than a JIT compiler, so this is a poor comparison point.


This made lo cal operations faster, although it also made remote operations slower, because all direct pointers had to be translated when theycrossed from one machine to another.

the slowdown caused by translation was small compared to thecostofanetwork operation.The principlewasthat users shouldpayforafacilityonlywhentheyusedit:wedidnot want to slow down local operations just to make remote operationsfaster.


In contrast to our model, it simulated the concurrent development that allows overlapping between increments.

at current stage, we do not consider the increment dependency in our model.


This data can be used in both current and subsequent dealings.

3.3.4 Suitable resource identification in some cases user may not have precise knowledge of the resource most suited for executing the specified application.


Variability-Aware Change Impact Analysis of Multi-Language Product Lines Florian Angerer Advisor: Hanspeter Mössenböck Christian Doppler Laboratory MEVSS Johannes Kepler University Linz 4040 Linz, Austria .orian.angerer@jku.at ABSTRACT Change impact analysis (CIA) techniques have been applied successfully to determine the e.ects of modi.cations when evolving software systems.

many software systems today use multiple programming languages and they are organized as software product lines (SPLs) to ease their customization to di.erent customer and market needs.


For example, we applied an abstract interpretation technique [11] for software prefetching in our JIT compilers.

the symbolic analysis techniques are powerful but more time consuming.


$10.00 parser DSL (Leijen and Meijer 2001), and a pretty printer EDSL (Hughes 1995).

these EDSLs are completely independent, which precludes the use of a single embedded program to specify both parsing and pretty printing.


At 100% of sampling frequency, the average (90t h %ile) latency is 7% (10%) higher than the corresponding latency in the baseline memcached.

at the default 3% sampling frequency, the average and the 90t h %ile latencies of SPORE are both within 3% difference of those in the baseline memcached.


Undoubtedly, these systems require support that goes be- yond what Jumbo can offer and therefore need to be built into Java compilers and run-time systems in some ways.

to a first order of approximation, these are just RTCG systems, and Jumbo provides a simple way to exper- iment with such ideas.


Merlin is similar, in that policies allow users to specify packet-processing functions.

merlin does not directly target cloud-services.


We decided for sioc:UserAccount mainly because we also use several other SIOC concepts along with muto:Tagging and can thus stay in the same namespace, which facilitates linking.

as sioc:UserAccount is a subclass of foaf:OnlineAccount, concepts from the FOAF vocabulary can also be used (e.g.


More importantly, these vector types and operations provide regions of implicit data parallelism that should allow users to transparently exploit emerging parallel hardware.

the dynamically typed semantics of these languages make it dif.cult to extract this data parallelism.


Our three cases (constant, related to the size of class, and related to the size of modification) are somewhat extreme.

as we see it, they can still be useful in a decision making process.


The above constrained optimization is similar to the energy optimization in previous statistical DVS algorithms [7, 11, 21] in that all of them .nd a speed for each of the allocated cycles to minimize their total energy.

pDVS differs substantially from previous statistical DVS algorithms (and generally most of previous DVS algorithms) for two reasons: First, PDVS explicitly considers the discrete set of speeds when optimizing energy.


The human brain has an easy time distinguishing which parts of the image come from the video, and which come from the text.


It invokes the build tasks of sub product lines by calling the respective build tools (e.g., make, ant) in the correct order with correct parameters in order to build a compound product.

to be able to apply this solution, one must already have rightly understood how the subordinated build systems need to be handled.


Since cameras 2 and 3 overlap slightly, it is likely that they have a corresponding homography and thus camera 2 could send the location directly to camera 3, e.ectively using a shortest path approach.

camera 1 overlaps signi.cantly with both cameras 2 and 3, and therefore could have a much higher quality homography estimate with both cameras.


Such an adversary can be comprised of any number of colluding routing nodes.

we assume that publishers are not part of an adversary against subscribers because publishers can always modify the aggregated data by providing malicious input data while otherwise following the aggregation protocol properly.


IE 9 enables an XSS .lter by default [23].

iE-based browsers, such as IE Tab, use the same browser components as IE, but do not enable the XSS .lter.


NSGA-II outperformed random search in finding solutions closer to the best Pareto front.

random search seems a feasible alternative for small instances or those with large budgets.


Since introductions change the structure of the base program, modeling introductions as program (hence graph) transforma  tions is very intuitive.

it can be argued that this is not necessarily the case for other types of aspect compositions.


Since for smaller failure rates more test cases are necessary and thus the .rst test cases become less important, the fact that the mean F-measure of both D-ART and RRT decreases for lower failure rates can be explained.

the position of the local maximum varies in the failure rate by the obvious scaling factor ..


Based on this evidence, strategies for hardening kernel data structures against errors are being explored [10].

evaluating the e.ectiveness of a hardened kernel is di.cult in the absence of an e.ective way to induce errors throughout the entire memory footprint.


The different node classes form a lattice where the bottom node is capable of handling all cases.

this big and complex method is rarely executed.


The hardware cost, the energy expenditure, the form factor, the small range, all are difficult compromises, and it is hard to envision cheap, unreliable and resource-constraint devices make use of range-based localization solutions.

the high localization accuracy, achievable by these schemes is very desirable.


Completeness has been shown for the p-calculus and XML types [15].

to our knowledge no such results exist for systems similar to ours, e.g., Scala, or vc.


Object Dependence Graphs were used to maintain a record of dependencies among objects, thus when new information entered the system, graph traversal algorithms enabled the efficient propagation of the updates to the relevant objects.

as is the case with alternative mechanisms, the scalability of the algorithm severely restricts its usefulness.


Compared with rechargeablebatteries[1,2,3], capacitors ownsseveral advantages:(i) morethan1millionrechargecycles;(ii) predicable remaining energyindependentofdischarge modes;(iii) more robusttotemperaturechanges, shock, and vibration; and(iv) high charging and discharging e.ciency.

there is one major challenge in the capacitor only systems: the energy leakage of ultra-capacitors is high when they reach their full capacity, as shown in Fig.1.


In some cases, the error symptoms are not captured by any logging message, while in some other cases, the logging messages are too general to offer path information.

with the increasing complexity of software, developers are likely to design more informative and discriminative log messages to help them diagnose problems encountered by their customers in order to retain their customers.


It is unlikely that the work.ow execution fails by itself not counting bugs in the newly developed actors.

machine failures can bring the work.ow down, too.


Note that we have introduced a symbolic variable x0 despite thefact that the code has no input.

traditional symbolic execution of the code creates a memory map where x maps to 1, y maps to 2, and z maps to 0.


Rescheduling of the instructions without breaking them into streams has a limited effect to the compression ratio because horizontal and vertical correlations are opaque to the compression algorithm.

when the instructions are split, horizontal and vertical correlations of streams are exposed.


This is not an issue in the current static semantics of AspectJ because all aspects must be loaded before classes are loaded into the VM, and so there will never be stale methods.

one of the potential advantages of a runtime architecture is to support more dynamic behaviour than is speci.ed in the AspectJ language.


For example, in [24] the predicate dle(v,u) allows to synthesize the summary for a procedure that sorts in ascending order, but cannot be used for a procedure that sorts in descending order.

using the pattern y1 = y2 allows with our approach to synthesize the summaries for both kind of procedures.


As system libraries are compiled beforehand, a library must have a single static type.

in CCured, one wild pointer may pollute other values by forcing them to be the wild type, including data to be passed to the system library.


Reiss [14] constructed and visualized a simplified memory ownership graph to reveal memory problems in the Java heap.

these techniques are of limited utility for unmanaged languages.


New functionality, bug .xes and extensions can all be integrated without having to quit the application.

reinjection of global state is only safe if the de.nition of the state data type is unchanged in the new code.


In other words, our approach does not require any syntactic extensions to existing AOP languages.

the above pointcut de.nition is not practical with current AspectJ compiler implementations as they evaluate the condition at runtime7 .


Due to possible loss of information, which is unavoidable in static analysis, there is no guarantee that the recommended con.gurations which will be the best in terms of performance.

performance annotations are still useful for guiding the process since, in most cases, the recommended con.gurations will be close to the optimal result.


Applying this result directly to an instance of the Dyck-CFL problem with k parenthesis kinds and n graph nodes yields an O(k3 n 3) running time.

we can sharpen this result by specializing the complexity argument to the Dyck-CFL grammar.


Given the increasing demand on highly-utilized cloud, a fast and silent migration will be of paramount importance.

existing VM migration schemes are not suitable for such highly-utilized clouds by incurring a signi.cant performance overhead to both the migrating VM and other VMs running in the cloud, due to the latency-and bandwidth-critical memory transfer mechanism.


It gives information on the data being exchanged, the sequence of messages for an operation of the service and the description of binding [27].

wSDL specifications lack semantics which profoundly affect the correctness and completeness of service composition [33].


In Figure 2, to navigate from page Y to page Z the user must be logged on.

although user can be logged on at other pages, further examination of the navigation map shows that it is not possible for a user to be logged on while visiting page Y.


We de.ne requirements contracts in a system because requirements are de.ned over the input/output interface of the component and should not be de.ned in terms of implementation details.

we perform proofs at the system implementation level, where we can use the contracts of subcomponents and their architectural relationship to establish system level properties.


2.2.7 Other Class Extensions MultiJava currently allows only instance (non-static) methods to be added to existing classes.

it should be straightforward to extend our work to allow top-level static methods and even top-level static .elds.


Roughly divided it either plays the part of being the object of analysis or the means for cre-ating other data materials (Petersen & Østergaard, 2003).

the functionality or nature of the photograph also differs.


In order to avoid restrictions on sharing between individual data structures and to avoid maintaining per-object reference counts, we group objects into regions.

rather than attempting to craft our own custom region-based type system from scratch, we will take advantage of a large body of pre-existing literature designed speci.cally for controlling volatile resources the literature on linear type systems.


So, we have shown P m is equivalent to P at least for the schedule .no.

if there is a WRITE action by another thread between ai and aj in ., then we may have vi vj .


as explained in §7, the soundness of self-certi.cation limits the extent to which re.ection can be used when checking certi.cates.


For example, it is hard to design a good replacement policy that a) behaves comparably to LRU in replacing pages that were not recently accessed; b) eagerly replaces pages that are accessed only once, similarly to LFU; and c) behaves optimally for large linear loops.

it is easy to .nd simple policies (LRU, LFU, loop detection) that capture a single locality characteristic each (recency, frequency, or optimal behavior for linear loops).


MARTE Time model includes both structural and behavioral aspects and does not focus on one speci.c diagram.

we do not consider the whole behavior nor the whole metamodel.


Because the generated .J S programs are huge, executing .J S programs has been absurdly slow.

our formalization is similarly rigorous but much easier to understand because it is a source-to-source translation, and our implementation is much more ef.cient and practical.


This is not represented in Figure 5, which assumes that the trust values are computed correctly.

it is unlikely that over 40% of the peers in a network are in a single malicious collective, unless the malicious collective is a result of pseudospoo.ng (a.k.a.


That is, given a classi.cation at iteration n, the starting position for the trace segment at iteration n + 1 is determined by the length of the classi.ed trace.

if the classi.cation at iteration n was incorrect, the starting position for iteration n + 1 may be incorrect.


ResultsinFigure14(c) show that mean localization errors remain constant acrossdifferent nodedensities.

when the number of target nodesincreases, the average maximum errorincreases.


It is a recognized best practice by many object-oriented software developers [1, 7].

it is rarely taught in the computer science curriculum, and few guidelines or pedagogical approaches exist for how to teach these concepts.


Since the current version of SPI exploits static predictability properties of SDF and associated inter-processor communication strategies which are not present in the general KPN model, it cannot be used in conjunction with arbitrary KPN representations.

integration of SPI with KPN especially, restricted versions of KPN that are more amenable to formal analysis as demonstrated by tools such as Compaan [15] is a promising direction for future work.


If p is too low, many tasks will get delayed, adversely affecting job completion and underutilizing resources.

if p is too high, many long running tasks will get scheduled.


The only solution is to require that the Exists data type package the necessary type class dictionary itself.

data Exists :: * where Ex :: Size a => a -> Exists instance Size Exists where --Type checks gsize (Ex (ex :: b))=1+ gsize ex this is simply not scalable as every time we would like to use an open type-directed function on values of type Exists it will be necessary to add another constraint to the data type de.nition.


these approaches generally hard-code speci.c domain knowledge and cannot be customized simply, if at all, in the same way our approach allows.


First, requesting process sends an address packet containing the address of the data element and the corresponding data packet contains the requested data element.

as mentioned earlier, in case of a write, a single write packet is suf.cient.


As the .gure shows, in the slow cases, namely NFS and local disk,it makes little difference whether the target buffers reside in main memory or NIC memory.

when reading from a (fast) RAM disk, the data clearly show that keeping data buffers in main memorygives the better performance.


And the goal of Equation (6) is to compute the maximal time t to which Ji and all the upcoming higher priority jobs can be procrastinated without violating this requirement.

the level-i latest starting time LSTi(t) computed by Equation (6) can only guarantee the feasibility of job Ji but not necessarily any other lower priority jobs.


While in certain scenarios this distinction turns out to be useful, and even desired, it is restrictive in the case of behavioral re.ection, and is one of the reasons why more recent derivatives of such re.ection (e.g., [17]) avoid proxies.

for associating a behavior through a dynamic proxy as a meta-level object with an existing base-level object, the invocation handler associated with the corresponding proxy would most likely have to be given a reference to that object, and henceforth, the proxy would always have to be used instead of the original object, for instance also for self-invocations.when a method of the actual target object invokes a further method of that very object, there is no way of intercepting that invocation ( self problem [19]).


Some applications must be executed concurrently and thus have to be schedulable together.

if we tried to execute all applications at the same time, the system would not be schedulable.


This means that in the nondeterministic choice at the end of Algorithm 8 there could be more reductions possible than there should be.

as we restrict ourselves to LR(k)grammars, this turns out to not be a problem.


Measure Category Halstead Internal-code-based McCabe Internal-code-based Shepperd External Henry & Kafura Hybrid-code-based We believe that any complete complexity measure should be in the hybrid category, because the complexity of a module is a factor of both Internal and External complexity.

much research has focused on only one of the two approaches.


Further, a process cannot exist on more than one satellite kernel and therefore the threads within a process must all execute on the same satellite kernel.

since applications are composed of one or more processes, applications do span multiple satellite kernels.


Initially, bundles are completely isolated from each other.

code sharing on the basis of Java packages is possible between bundles.


It can be noticed that events do not have information about spacial information for the moment.

some research about spacial information and geolocalisation, like in [25], can be added to the events to improve them.


To the best of our knowledge, all research on optimistic replication for weakly connected environments assumes such situations of weak (or no) connectivity are .xed impositions of the environment; hence, their goal is to ensure the highest quality of service, despite such an assumption [19].

connectivity in today s mobile networks is not as immutable as commonly modeled.


There exist many techniques to accomplish performance scaling at the node level, such as radio transmit power adjustment [1], dynamic voltage scaling [2], and the use of low power modes [3].

these techniques require hardware support and may not always be available on resource constrained sensor nodes.


This is similar to our approach in that we are also providing implicit parallelism annotations to the compiler to compile into an appropriate locking scheme.

the domain of our application, parallelizing event processing of a distributed application node, is substantially di.erent, and di.erent approaches are warranted.


Note that dead code is not a run-time error like division by zero or array out bounds.

the maintainability is in.uenced in a negative way since there are redundant blocks used.


In our experience, the most common sources of non-determinism are memory-safety bugs interacting with ASLR and resource-exhaustion conditions such as timeouts and memory limits.

even deterministic bugs can be resistant to reduction, particularly when these bugs stem from internal resource limits in a compiler.


, there should also be a way to delete the structure using the keyboard.

our evidence suggests that backspace was a versatile deletion mechanism because it only depends on the text caret position, and not on the editing history; thus, such deletion mechanisms should not depend on the editing history either.


Inlining the implementation thus resulted in complex Boolean expressions in contrast to the very simple Boolean expressions in the non-inlined version.

the Latctl Batch system, with the least coverage reduction among the industry sized examples, was primarily a functional transform with less complex mode logic and inlining did not have a dramatic e.ect on the complexity of Boolean expressions.


Some of these problems also occur in delegation-based systems and di.erent solutions have been proposed (see [19] for an overview).

most of these approaches do not really .t in our model, because all .elds are the potential targets of CRs, so that trivially type safe restrictions like requiring the new value of a .eld to be a subtype of the dynamic type of the previous object are not practicable.


Such rules encode behavior for .nding potential bugs and suboptimal code.

these rules can be dif.cult to create and many are dif.cult to understand.


Note that problems linked to the presence of hot spots and single points of failure in DHT-based systems can be mitigated introducing replication and load balancing techniques.

these techniques introduce other problems (e.g.


About adecade ago,in responseto agrowing clamor about the limitations of N-1 checkpointing bandwidth, developers for this application augmented their checkpointing library with .fteenthousandlines of code.

instead of changing the application to write an N-N pattern, they added a new IO routine in which interprocess communication is used to aggregate and bu.er writes.


Currently, search tools available in the market such as Thomson Reuter s Delphion and Web of Science provide a good starting point for trained professionals to perform Boolean searches within a single information silo.

users of such tools belong to different backgrounds (for example lawyers, startup companies, academicians etc.


For purposes of copyright protection, watermarks that are robust and invisible are desired.


Therefore, it is impossible for any stateless model checker, including ours, to generate all fair executions in a bounded amount of time.

for checking safety properties, it is only necessary to generate enough executions to cover all reachable states of the program.


We listed some influencing factors for our cost model in the preceding section.

we must express these factors in mathematical notation for further analysis.


z x Figure 2: Activation condition 3.1 Sporadic activation All synchronous languages propose some ways of preventing a component from reacting (the suspend statement of Esterel, or the clock mechanism of Lustre and Signal).

we don t want to bother about absent values or signals, induced by those notions.


Note that the canonical expressions of syntax trees look just the same as they did in the case of mutual data types and the universal tree type.

their types now have the form Tree c for some c. If we want, we can give the dummy types different names, for example Stm , Exp ,Var ,and Typ , and use type synonyms to make the types also look like they did when we had multiple data types: type Stm = Tree Stm_; type Exp = Tree Exp_ type Var = Tree Var_; type Typ = Tree Typ_ 4.2 Compositional operations The power of inductive families is shown in the de.nition of the function compos.


For instance, the following program is ill-typed, let f = readFile "DATA" in (fPutChar O f, fPutChar K f), because the .le f is used twice in the body of the local de.nition.

the program let f = readFile "DATA" in fPutChar K (fPutChar O f) is type-correct: the .le f is used only once.


These new classes use transactional boxes from the JVSTM, so that the domain objects can be transactionally manipulated in Java, independently of the database.

the durability of the JVSTM transactions continued to be provided by the Ob ject/Relational mapping provided by OJB, which allowed us to keep the same relational database structure as before.


The only problem is that the rational numbers .i(K) are returned as .oat numbers, and not as the quotient of two integers.

as each .xi is an integer vector, we use a post-processing step to compute .i(K) as a fraction: it is the smallest rational number such that A.xi =..c. We thus consider each equation of this system to build .i(K) as the quotient of two integers.


try to combine static analysis and aspects to control the execution of a program according to potential value schedules [19].

this approach does not handle control .ow well, and can produce an infeasible execution of a concurrent program.


Semantically, as typi.ed in [4, 9, 10, 12, 13], MSC system speci.cations are interpreted as deterministic and complete: mathematically, a set of MSCs completely characterizes all the behavior of correct implementations by requiring that they exhibit exactly the execution sequences the MSCs exhibit.

scenario-based * Research supported by ARO grants DAAD190110003 and DAAD190110019 and NSF grant CCR-0098037.


[a × b ] zipmap f (x : xs, y : ys)=(fx, y): zipmap f (xs, ys) zipmap f ( , ) =[] o In [14], the focus was on how to apply fusion on all arguments of a function simultaneously.

our solution is selective in the argument we want to fuse, and this is crucial to enable fusion of functions with accumulating parameters as we will see shortly.


This is a correct approach as a validation tool or for running streaming applications on full-size computers.

in the embedded world, a lighter approach is needed as memory is usually a scarce facility, and embedded targets require special attention to power consumption and code performance.


This initial work suggests that the death context of an object may be a stable and predictable feature.


Therefore, it has suf.cient information to decide if a drill-down will favor the increase of the exact-match queries for its values.

a node has to cooperate with other peers that store a value of a level i < pivotlevel in order to decide if this level is more appropriate.


Noncommutative Effects In the previous section we saw two examples of how monad transformers are used to access the operations needed to de.ne evaluation algebras.

in some cases separate features can interact in multiple ways, and this is re.ected when applying the associated monad transformers in different orders [26].


Like shared variables, global variables are also declared outside the scope of an agent.

there is an important difference between global and shared variables.


Speci.cally,the type of a declaration element E is shown as the constant value [E]P .

the declaring class of a member M is shown in unsimpli.ed form (i.e.,as Decl(M)) because the Pull Up Members refactoring may change the location of members in the class hierarchy.


Method Differentiator Using Slice-based Cohesion Metrics Akira Goto1, Norihiro Yoshida2, Masakazu Ioka1, Eunjong Choi1, Katsuro Inoue1 1Graduate School of Information Science and Technology, Osaka University, Japan {a-gotoh, m-ioka, ejchoi, inoue}@ist.osaka-u.ac.jp 2Graduate School of Information Science, Nara Institute of Science and Technology, Japan yoshida@is.naist.jp ABSTRACT It is important to understand semantic di.erences between a pair of Java methods during maintenance.

textual or syntactic di.erence is insu.cient to give clear idea which code fragment realizes a single functionality in Java methods.


The participants are aware of the importance of adaptation, since they stated to consider context-awareness while developing their applications, which validates to some extent H1.

concerning H2, it is remarkable that adaptation is not largely employed, which may result in static applications that are not suitable for dynamic and varied contexts of use.


Clicking on a proposal shows an additional yellow window previewing the changed code.

the developer still needs to answer the following questions about each proposal: Does it resolve this compilation error?


Entry point discovery is essential to revealing whether the user is aware that a certain API call has been made.

this identi.cation is not straightforward.


burstiness can greatly worsen the performance of static policies when the mean arrival rate is unknown.


An insensitive algorithm maintains a single abstraction of each .eld, and is unable to distinguish between the values of corresponding .elds in di.erent instances of the same class.

a data context-sensitive scheme models .elds of class C separately for each distinctly-labeled allocation-site of class C. Data context-sensitivity is sometimes called .eld cloning or the creation type scheme [48].


An advantage of this algorithm is that it is easily adapted such that more neighbors of a search point can be found fast.

both NN and ANN algorithms cannot be used directly in our calculation algorithm.


First observe that the two refinements of X to G and to F are both conservative over X.

also, G and F are independent and the weaving from X to F does not modify variables of G. their composition, dX /dF * dX /dG is not conservative wrt X, as the last adaptor checks if both features X and G are present and only then modifies variable a.


We only measured the subset written in C due to the limitation that Diablo, the binary rewriter we use, is language dependent.

the described technique works at the binary level and is independent of any specific language.


The part of the similarity graph in Figure 13(a), which shows the .rst phases of the trace tree, is highly regular: at .rst, a new phase is detected after about 500 side exits.

each new phase is slightly shorter than the previous.


we observe uniformly much lower energy consumption for DR. Swap compared to eMMC .ash backed swap.


We showed in [Blind] that the construction of ADLs could be done automatically with association rule mining.

in this work, we introduce two more aspects to our library that require temporal knowledge.


The read cost reduces sharply by 72% as the buffer size increases from 8 bytes to 64 bytes.

beyond 64 bytes the per byte cost decreases more slowly and larger read buffers have relatively less impact.


These techniques let the user conveniently observe and monitor the dynamic behaviors during debugging.

because these techniques do not emphasize on correlating the monitoring of the program actions performed at di.erent points of time during execution, they provide inadequate support for the direct observation and inspection of the progress of the scenarios for a particular task.


Because AspectScript would not work on JavaScript extended with a new keyword (transaction), we tested the reference implementation using regular extracted JavaScript functions.

if the transaction keyword is to be added to JavaScript, AspectScript will probably be extended with transaction-speci.c pointcuts.


Whilst a synthesised attribute is evaluated by traversing the AST top-down, inherited attributes are implemented in the JastAdd system by traversing up the tree.

polyglot visitors only traverse the tree top-down and left-to-right.


This may result in an overall system behavior that maybe was not intended.

the proposed MDA approach always has the view over the entire system trying to optimize it in a way by which each of the participating systems can benefit.


The cardinality of [1..1] for PaymentTypes means that the payment aspect of a system must include payment types at least and at most once.

fraudDetection is optional, i.e., its cardinality is [0..1], as indicated by the symbol .


PM,i is the performance cost for type i instruction on machine M and PPM is the vector form.

if we take into consideration di.erent instruction schedules, stalls and Instruction Level Parallelism(ILP), PPM is not a constant for di.erent algorithms that have varying instruction mixes and schedules.


It might be an intentional design decision for practical .exibility and .xing this problem mightbe possible by adding extra declarations.

this confuses the discussion on the modularity of AOP.


l2 Then, there are no extra run-time tests on x,since theconstructor rule applies.

patterns p2 and q2 are now compiled twice.


In connection with XML, we have shown how the principles of UnQL will work on an ordered tree.

it is not clear how they can be extended to an ordered graph model.


These parameters were estimated once during the performance evaluation of each partition in Section 5.

during the .nal code generation step, we compute the exact SM memory layout, and the resulting footprint may increase due to fragmentation.


the main purpose of the PID is to provide a better calculation of what the heap size should be, rather than determining how frequently we resize the heap.


We analyzed sendmail-8.7.6, an old version that was released after a thorough code audit of version 8.7.5.

this version has several known vulnerabilities.


Then, the test will reject the null hypothesis H0(p).

h0[c1,c2](p) will be rejected only if c1 = c or c2 = c. Low separation index of a pattern indicates that the pattern prevalence is more stable in different collections.


Our operation descriptors tend to be small, so the cost is often the time to .ush a only single cache line.

v-to-NV pointer manipulation and read logging are extremely inexpensive, because they do not require durability guarantees or, therefore, epoch barriers.


One of the .rst publications in this space was the work by Harish and Narayanan [10] who presented the .rst algorithm to perform an ef.cient breadth.rst-search on the GPU.

this approach was based on visiting every node at every iteration, and was less ef.cient than the most ef.cient CPU implementation at that time.


If we were willing to accept substantial overhead, a natural approach would be to serialize the processing of incoming messages at the leaves using a parallel-pre.x computation [15], taking advantage that the e.ects of processing the various incoming messages on the states can be summarized as simple state updates plus possible assignment to the variables waiting and obj,and such operations are composable.

this approach could in the worst case require a parallel-pre.x operation on the entire tree to collect and process a single incoming message, giving an O(n)worst-case blow-up in message tra.c.


E :: []IEa IvE I(E : *)IletxE ina Naively, a sequence of non-syntax-directed typing Rules GEN and The reduction relation -is parameterized by a set of d-rules of INST should be placed around any other rule.

many of the form (d)below: these occurrences can be proved unnecessary by following an appropriate strategy.


Rule (C2) is similar for the get operation.

here two new noti.cation terms are created to resume the wait operations while the t(s) suspension term is consumed.


By excluding the upcall edge from our analysis, we can eliminate this kind of cycle.

the general problem of detecting false alarms in the cyclic dependencies is a bit harder.


In [30], several implementation variants using ATL, e.g., using either imperative constructs or declarative constructs, of the same transformation scenario have been considered and their different runtime performance has been compared.

these works only consider the traditional execution engines following a sequential rule application approach.


The PLUTO compiler applied the loop optimizations well to enhance cache reuse.

since it relies on Intel icc to perform the backend CPU-level optimizations, the overall  Our matrixOpt applies 10 .nely-coordinated optimiza tions in a pre-customized order, shown in Fig 7.


We analyzed this by defining as (approximated) debugging time on the experiment data and performing a corresponding significance test.

the result has been rather surprising: while in the small task no significant different could be measured, in the latter one the statically typed group required significant more time for fixing the type errors.


In service-oriented computing [11], a broker manages the information of service providers and consumers, and performs matchmaking among them.

as the number of involved services increases, the size and complexity of information to be maintained increase drastically and such complexity usually results in a brittle system.


In fact, contribution should be simple and barriers should be avoided, in order to increase participation.

the need of improve quality of information, often require the identification of the participant.


4.2.4 Execution of Tests When using Amsterdam to test an application as it runs in the .eld, it is assumed that the application vendor would ship the application including the con.gured testing framework as part of the software distribution.

the customer organization using the software would not need to do anything special at all, and ideally would not even notice that the tests were running.


Hence they seem ideal for in-memory server applications.

they do not seem likely to replace DRAM in the near term (2 5 years).


Also, for the test of the temporal properties of a system, such as the worst-case or best-case execution time, generic approaches exist which can be easily applied to the testing of the embedded system under consideration.

for the test of functional properties of the embedded system, such as certain safety requirements, the fitness function must be manually designed to account for the functional property at hand.


A potential weakness of using CPN in the emulation environment is that models de.ned using CPN may not be as e.ciently executable as endpoints directly encoded in programming language.

the results of a case study in emulating LDAP endpoint systems presented in Section 5 demonstrate that the run-time performance of the CPNbased approach is su.cient for simultaneously emulating the behaviour of up to 10,000 LDAP endpoint systems.


In our approach, we have to concede the imprecise nature of IR, and therefore incorporate errors in the first place.

our approach can save the cost of designing and executing so many test cases.


Even if areahad a default implementation, as in Figure 3, glue methods would still be useful, allowing clients to customize the integration of the area and triangle libraries.

rMJ allows glue methods to be written but issues a compile-time warning that there is the potential for duplicate or ambiguous methods to appear in other .les.


Techniques for converting Array-of-Structures to Structure-of-Arrays do not apply here, as multiple .elds in the structure are also accessed together in other parts of the application, where fetching the whole structure is desirable.

the scatter-gather fetch feature of modern DMA engines can be used to select only the desired elements scattered at .xed strides in main memory, and place contiguously in SPM.


The plots show correlations between the histograms computed on the tra.c at these locations for source addresses.

for the same reasons mentioned in Section 1, it is ideal to not rely entirely on a signature-based assessment of normal vs. anomalous histograms.


The outputs would have to change from v to v' (if v' re-mains the input long enough).

when different input values are presented, there is usually free- dom in which decision to take.


If the component is used unmodified, then it can be added to the shared architecture.

if the component requires modification, then it must be decided whether a second independent version of the component is to be created or whether a reusable version of the component can be created that is suitable for use by both projects.


Thus, PE3, PE4, PE5 and PE6 in the training sub-DAG are identi.ed to be the splitting points and executed in parallel.

the above split causes every remote machines to send the extracted features produced by PE6 across the network to the .nal machine that executes PE8 and PE9, which is the largest data stream in the entire work.ow.


SMARTEDIT [19] also used version-space algebra for PBD, but when confronted withaversion-space collapse,SMARTE-DIT just reportedfailure to the user, who could then provide a new trace.

cHINLE exploits thefact that the algebraic description (illustrated as the treein Figure4)factors the version space wherever there is a VS join operator (.).


This is a coupling minimisation technique: it limits how many decisions concerning the environment are visible to a module.

we have established that some coupling is unavoidable.


In this case 1 synchronization, if necessary, has to be managed by hand.

syncex marks remote advice for synchronous 3 execution.


In this context, static analysis is applied to reveal existing weaknesses and to insert run-time checks.

iFT statically veri.es information .ow properties for Android applications.


Thus, the customer may purchase a better performing but more expensive system if the maximal required bandwidth is high.

if the maximal required bandwidth is below 2 GBit/s, it is always advisable to purchase the standard bundle with only one 1 GBit NIC, eventually plugging an additional 1 GBit NIC.


Both particle and feature-based methods are critical to describing and understanding large scientific data.

little effort has been put into the enhancement of analysis and visualization using both data types.


Conceptually, MDD is mainly a top-down approach, as it promotes incrementally transforming models of a system to code, while CBSE focuses on run-time composition of components executable code, making it a bottom-up approach.

looking only at design-time, which is in the focus of our research, CBSE and MDD overlap, and the border between the two is fuzzy.


Both problems can be restated in terms of DASH-style reachability problems, one for each target code element3 .

straightforward applications of DASH do not scale.


For instance, if the total order function chooses the system that provides the best absolute local response times, the scheduler would choose the process-first scheduling policy.

if the function chooses the system that provides the best remote response times, the scheduler would choose the transmit-first (or concurrent) the concurrent scheduling policy.


Functionlevel weak-lock is ineffective in this case, because two threads may execute the memset concurrently.

our static analysis determines the bounds of addresses accessed within the hot loops of memset fairly accurately, which enabled us to use loop-level weaklocks effectively.


Although middleware has been proposed for larger systems, the high memory and computational requirements make it impractical to many low-power, memory-constrained miniature sensor nodes.

given that memory is one of the largest energy consumers that must stay on more often than RF, many wireless sensor nodes cannot afford to have a memory larger than a few kilobytes.


Since leaking arbitrarily on the progress channel is unacceptable in practice, CP-security is a much more reasonable property to aim for.

cPsecurity is hard to enforce permissively [53]; typically, looping on high data is disallowed.


When the cooperating subsystems are also state based a method is required to compose them together.

a desirable quality is to reduce coupling between the subsystems state machines.


This showed that in dimensionality reduction issues, number of features is not the only factor that influences the classification result, but the other factors such as population, inertia and iteration also play important roles and need to be considered.

in terms of recall, even though the proposed method achieved 91.36%, lower than FAMGA and NFSS which is 97.88% and 97.15%, but our method is still able to give a competitive result.


[11] highlight the effort-benefit disparity in this parallel use of email with CVS (the people reading the message derive more benefit than the person who has to put in the effort to send the message) but the developers did not mind this as they knew they would also benefit at some other time from someone else s effort.

even though the developers stated that the combination worked for them, some studies [4, 23] observed situations where it did not, for example rushing to commit changes first to avoid having to deal with merges.


This allows us to exclude toy or experimental projects from the analysis.

doing so might also impose a threat to external validity.


Popular examples are smartphones which usually provide a multitouch screen, speech input and motion sensors, or the Microsoft Kinect, which enables full-body interaction with a game console.

the design of development tools and application programming interfaces (APIs) has not kept pace with this new trend.


Commercial products such as AppShield [58] and InterDo [43] use a similar approach.

even though it provides immediate assurance of Web application security, it requires the correct identification of and validation policy for each individual entry point to a Web application.


CONCLUSION Garbage collection plays an increasingly important role in nextgeneration Internet computing and server software technologies.

the performance of collection systems is largely dependent upon application execution behavior and resource availability.


On the one hand, an overestimation leads to unsafe variants of a DSL, i.e., some variants rely on missing foundations.

an under-approximation does not exploit the full range of features o.ered by a DSL.


In order to capturethe concrete syntax, we adopt a by-demonstration technique, which is similar to earlier work on Program ByExample (PbE) or Query By Example (QBE) [4][8].

maintaining an optimized sequence of actions(i.e., pruning unnecessary actions) while preserving thedemonstrator s intent is challenging.


It may still be necessary to perform dynamic tests to determine when advice applies.

aspectML allows advice to be installed at any time.


If a packet is no longer referenced, it is good practice to discard the packet as quickly as possible, not to exhaust packet buffer pool on the system.

checking whether packets are referenced can be expensive.


3.2 Base Type: Symbolic Links When symbolic links occur in a described .lestore, Forest follows the symbolic link to its target, mimicking standard shell behavior.

forest allows programmers to specify explicitly that a particular .le is a symbolic link using the base type SymLink.


In the case of uniform loss probability the delay of the recovered packets is almost constant.

when the link experiences loss bursts, multiple packets are likely to be lost in a row, and therefore it takes longer for the receiver to detect the loss.


Moreover, for iterative consensus algorithms in a time-invariant network, existence of a directed spanning tree is a necessary and suf.cient condition for achieving agreement among the nodes [12].

the full utility of edge reachability and network robustness is realized only when considering fault-tolerant and resilient dissemination of information in a network through purely local strategies.


That is, we can .nd smaller of two objects using min provided we can compare them by <.

there are notions of smaller that are not conventionally expressed using <.


(But we also do not have a counterexample.)

this claim about stack reduction is not essential to the overall proof: Lindley and Stark use it only to establish the fact that stack reduction does not increase the stack length, i.e.


Parameter smallestSlice puts a lower limit on how small a request for time slice can be, and parameter.

requests for smaller time slices are not outrightly rejected.


However, it provides no abstraction on the event-driven side: the scheduler uses a low-level, unsafe programming interface that is completely hidden from the programmer.

many event-driven systems uses continuationpassing style (CPS) programming to represent the control .ow for each client; the problem is that CPS programs are often dif.cult to write and understand.


with a motivated team, good project planning and the willingness to build new skills sets, we found it possible to develop an application that meets our requirements and serves as a catalyst for future improvements.


Based on how it was designed, we expected that our stack over.ow detector would not have any false positives with these cases.

in our most recent testing we found a fourth case that exposed a weakness in our original algorithm.


The two implementations of setPos method givenby Updater and Shape belong tothe Shape class at runtime.

since the implementation given by Updater overrides the other, it is invoked when the setPos method is called on an instance of Shape.


As discussed in section 2.1, this has adverse implications on the quality of the code within the tile and may result in losing parallelism due to the introduction of false dependences.

our optimizations take into account a speci.cation of schedule, tiling and placement on a processor grid.


old, the compiler cannot .nd much opportunity to apply our opti mization, and most of the time, each core ends up withperforming percentage improvement due to prefetching 20 16 12 8 10 its own data prefetching.

when the threshold is 5 low(50%), our approach startsbehaving similartotheindependent prefetching case.


Note that, in a few scenarios, there can be multiple tfields for covering tb.

currently we handle only those tb that can be covered by achieving desired value for a single tfield.


However, we do not foresee many issues in increasing the clock speed, since Haskell implementations demonstrate that it is possible to sustain very high rates of thunk allocation.

elliott [14] gives an implementation of streams using futures.


Using this approach, a larger number of irregular grid cells (and thus samples) can be allocated to the more detailed portions of the surface.

their algorithm requires more RAM than OoCS in order to maintain a BSP-tree and additional quadric information in-core.


.. .. 010 1 j 000 0 The form of af.ne schedule described above is a restriction on more general af.ne scheduling [24].

the key bene.ts of this representation outweigh its limitations.


Such a sequence may not end, if the environment defers providing a P forever.


Since an attacker can get more pro.ts by cheating at one speci.c state, an attacker s optimal strategy under PeerTrust is to cheat continuously for a while from a initial state.

the attacker will not have a high trust value if a lot of continuous cheat  (a) A trust value-based approach (OVER TRUST) (b) A rank-based approach (OVER RANK) Figure 8: The number of required transactions to reach a goal with two strategies ing actions are performed.


The Business Ontology is a complex hierarchy, with the ISO standard; every organization follows a high-level workflows process.

we often see that each country or each city or each individual company always has something different from each other.


Gribble [20] suggested several design strategies, including the use of systematic overprovisioning, admission control, introspection, and closed control loops for adaptation.

(experience such as reported by Parunak and VanderBok suggest that adding control loops might not solve the emergent behavior problem.


At this point, we have computed a permission map for the new contract.

further contracts may be installed already and these contracts must not be violated.


In this table, for all the three datasets here, +yes suggests that the tree-based GP simply adapted to multiclass problems is outperformed signi.cantly by the basic LGP, see table 2.

these results are slightly misleading as adjustingTGPby usingProbabilisticMulticlass methods(one of the best TGP methods for multiclass classi.cation) shows that(advanced) TGPperformssimilarlytobasic LGP,see table 3.


For performing the job the train driver has vari-ous supporting artefacts, like diagnostic on-board instruments and a telephone (artefact).

in the context of our Activity Theory analysis we would like to point out another contradiction, which is related to the company procedure concerning the communi- cation of the train driver and the line supervisor.


Progressive Meshes: Involve the initial transmission of a low polygon 3D model, followed by the progressive streaming of instructions on how to create more complex representations of this model [9] [31]  [22] [12].

progressive meshes can be timeconsuming to generate, and the model being processed must entirely .t into main memory during rendering, thereby limiting complexity of 3D models when implemented in mobile devices.


3D visualizations can overcome these drawbacks by enlarging the display space by the third dimension.

the opportunity to build dense visualizations may lead to a high spatial complexity and to obscuring effects.


Several methodsexistto .nd security relevant bugs.

analysing thousands of lines of code is not only time-consuming, but the number Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for pro.t or commercial advantage and that copies bear this notice and the full citation on the .rst page.


Figure 4: Di.erent notions of safety it on a new path.

the load expression is not down-safe at nodes A or B, since from each node a path exists in which the load expression a.x was not computed.


Virtualization techniques can transparently migrate computational state and network connections [Clark 2005].


Theoretically, an optimization such as the one described herein should follow uses of data de.ned in terms of the JNIEnv pointer to track all possible callsites that may correspond to JNI function calls.

it is harmless to perform this optimization on some callsites and decline to perform it on others.


Their elegant implementation packs .elds together in a memory word and relies strictly on atomic compare-and-swap and memory ordering instructions.

our implementation uses a simple lock on allbut the critical paths which can simplify many implementation aspects and also removes a level of indirection on the criticalpath.


Such a distribution is also bene.cial to the application because, the application has minimal risk of its requirement not being ful.lled in the event of a single server failure.

if there is a requirement to enforce one applications cache allocation to a particular server, we could just allocate the cache size determined by the .rst step of our algorithm on that server and our algorithm ensures that thespeci.edI/O latencyrequirement is guaranteed and the overall I/O latency is minimized with that allocation.


The API methods that a framework provides are called from within the framework.

libraries offer API methods that are called only from outside by the application that reuses them.


Instead we would like to apply the transformation .rst, then print the transformed values.

this would require a function of type ß .


In particular, Tarantula [Jones et al 2001] uses brightness to represent and extra attribute.

as noted by its authors brightness is confusing and very poorly perceived by the users.


The objective for the player 1 is to reach one of the states labeled as good , as in those states thread 3 can make progress without risking a deadlock.

player 2 can steer the game away from the two good states, thus reaching (1, 5, 1, . )


Therefore, it is guaranteed that the execution of these methods will not be interleaved, thus preventing high-level data races.

it is allowed for the execution of either of these methods to be interleaved with that of method Customer.updateAddress(), because the latter does not operate on the same atomic set.


Awais Rashid Lancaster University Lancaster -Lancashire, UK  marash@comp.lancs.ac.uk by means of dynamic software product lines (DSPL, i.e., product lines that are expected to re-con.gure at run-time [3]), has also emerged.

due to the large number of con.gurations that need to be supported, several of which might even be unforeseen, e.ective and e.cient testing of such systems presents a hard challenge.


Hence, one common use of the around() advice can be regarded as communicating data produced in a before() advice to an after() advice, within the scope of a woven method.

there are two severe limitations when using the around() advicefor communicatingdata across ajoinpoint: 1.


Telepointers can increase the presence of remote participants and can provide considerable awareness information about people s locations and activities.

the motion of a telepointer is often disrupted by network jitter.


For example, the Adobe Flash platform is widely used to develop and design multimedia applications, as it provides lots of features to help the graphical design.

it is very di.cult to provide reusability for these created graphics, which means usually the graphic designer only consider the current project and process when designing these graphics, and there is no way to reuse most graphics and design process for future similar projects.


The benefit of this is the ability to spend more time testing and improving performance and scalability.

a long duration is not without it s dangers.


As services are maintained by service providersindependently,themaintenancecostisdistributed to every service provider.

as the maintenance cost of centralized service discovery mechanisms is usually centralized into one or several organizations, it will becomeabottle neckwhenthenumberof servicesgetslarge.


Unlike linear sweep, this method disassembles instructions following the control .ow and can avoid disassembling data bytes.

this method fails at gaps in the executable that can only be reached via indirect branches.


4.1 OpenCOM DSL Existing models of OpenCOM based middleware families use a wide variety of notations that depend on the abstraction of the domain that is being modelled.

the basic concepts of any model specified in Genie relates to components, interfaces and component frameworks as the component model OpenCOM dictates.


Otherwise, the contract cannot be either printed or signed.

lOP status should be updated, e.g., loan offer calculated .


Contrary to insights from previous work, we discover that on modern NUMA systems remote wire delays, that is, delays resulting from traversing a greater physical distance to reach a remote node, are not the most important source of performance overhead.

congestion on interconnect links and in memory controllers, which results from high volume of data .owing across the system, can dramatically hurt performance.


To inform clients of such a dependency in a traditional module in- terface, requires exposing implementation-dependent information to client programs---a violation of the principle of information hiding.

if this information is buried inside the body of a procedure, then client programs will be unaware of the dependency.


2.4 Predicate Prediction with Selective Replay Mechanism Predicting predicates is a good solution to overcome predication problems derived from out-of-order execution, because all predicates are known at rename stage.

predicate mispredictions can produce a high performance degradation.


We compare the cost of the two cases of linear vs. randomly permuted communicator in order to estimate the costs incurred by the reordering step.

with the current MPI 3.0 standard there is no way of comparing to a zero-copy, datatype only implementation: such an implementation is not possible.


The translation process is somewhat similar to that of AAL [37].

because our declarative methods do not contain object creations, assignments, loops, or exceptions, the formulas for declarative methods our system generates are considerably simpler than the formulas for regular Java methods that AAL generates.


It is built around a tight integration with a batch system like Torque or Load Sharing Facility (LSF), leveraging the existing legacy system and avoids the split of the farm for Grid and Cloud access.

with such the tight integration, WNoDeS can only be run on speci.c HPC centers only.


Hence, subsequent invocations of this method execute the optimized code.

the Java method generated by Jython s custom compiler must be invoked at least more than a certain threshold number of times to trigger the recompilation by C1X.


Note that the latter is not a factor under control of the system designer.

its presence into the factorial analysis helps to evaluate how the system behavior change with different levels of connected stations and how each factor changes its influence with an increasing network load.


Considering risk management since the early phase can avoid such problems and contributes to mitigate these risks.

comprehensive details are still missing in the literature regarding the integration of the risk management during requirement engineering phase.


If any of the tasks fails during the execution of a Hadoop job, HyMR will not be notified since the Hadoop will handle the fault.

if the process on headnode fails, the job controller in HyMR will be notified and restart Hadoop and MapReduce job.


There are also proposals to improve QoE by designing better adaptive streaming protocols (e.g., [32]) and intelligently using multiple CDNs [40, 41].

these focus on existing CDN-based delivery architectures while we focus on the interplay between ICN and video QoE.


The Proxy, Adapter and Decorator patterns are examples of how important the intent of a pattern is; all of them are super.cially similar to one another, and often have a single collaborating instance to which they forward one (or more) messages.

the intent of the Proxy pattern is to forward the requests through some protocol (such as over a network); the Adapter and Decorator intercept methods between the caller and the delegation class and work together [16, page 139].


In Step 3, the write pattern generates several updates to thelogical block b.

previously in Steps 1 and 2, this logicalblock had a low update recency, and wear leveling already remapped it to the elder physical block F. As previously mentioned in Section 3.2, these new updates to the logical block b will cause further wear of the elder physical block F, making the prior remapping operation of the logical block b ineffective in terms ofwear leveling.


We tried several different ways to categorize patterns and we documented that process in our earlier paper [15].

we realized that even the most precise categorization does not provide suf.cient help to practitioners.


There is also a large class of recent work on efficient graph query processing using dedicated graph query processing systems or user-defined function based extensions of database systems.

this class of work is focused on either novel indexing techniques (e.g.


All (1,1)-NM commitment schemes we know of in the literature are in fact (1,u)-NM.

we can also construct an example showing that this need not be the case.


7.4 OCL Alloy and OCL are super.cially quite similar: both provide a means to express declarative constraints about data and transitions.

one crucial difference is that Alloy was designed to be an automatically analyzable language, so that instances of models, and counterexamples to claims can be machine-generated.


For example, version 5 of the system comprised 14 files identified as both coupling-increasing and buggy in the future.

table 5: Feature coupling increase as a Predictor of Bugs Version CI Buggy CI Not Buggy Not CI Buggy Not CI Not Buggy 1 2 0 302 837 2 7 0 299 835 3 4 0 292 845 4 1 0 295 845 5 14 8 274 845 6 0 0 257 884 7 2 3 240 896 8 11 6 227 897 9 5 3 227 906 10 0 0 235 906 11 0 0 234 907 12 0 0 234 907 Because of low values in the first two columns, we could only perform a chi-square test of independence for versions 5 and 8.6 for both versions 5 and 8 the chi-square test indicates a statistically significant relation between the "coupling increasing" and "buggy in the future" variables (p = 0.001).


As long as all threads are busy, each thread behaves as if it is performing serial execution, which tends to yield good locality.

for message-passing, concurrency is often mandatory to avoid deadlock.


copyright c &#169; 2011ACM 978-1-4503-0770-3/01/06...$10.00 erased by the Java compiler after the type check (type erasure) [1].in X10, generic typing is a core part of its type system.Classes that have different type parameters are treated as differentclasses(typerei.cation).Inaddition,X10cantreatnotonlyobjectsbutalsostructsandfunctionsas .rst-classdata.


However, this work uses a speci.c language to state what objects are located in a host, and modi.es bytecodes using Java re.ection.

our approach uses a general-purpose language.


We can similarly de.ne the weakest liberal precondition of a postcondition .post.

because we restrict our preconditions and postconditions to be conjunctions of equality predicates on individual memory locations, there may not be a unique weakest (or largest) precondition for a .post.


domains to interact without sharing secrets apriori.

public key encryption and signature veri.cation is very expensive in a WSN.


There are hints in [12] suggesting that in the pregame phase architecture should be designed and reviewed by the Scrum team and in collaboration with other teams.

the work related to software architecture is left disturbingly open in [12] and in many other sources, which has led to varying practices discussed in 2.2.


Careful code-tuning is imperative to achieve maximum performance.

the processor has no interlocks most potential con.icts in resource utilization are disallowed statically during code generation, but some cases produce unde.ned results.


It has also been known for a long time that an in.nite grammar can represent any language, decidable or not (Solomon 1977), and that the languages generated by many in.nite grammars can be decided (Mazurkiewicz 1969).

the result that monadic and applicative combinators have the same expressive strength for .nite token sets seems to be largely unknown.


In [8] Selby quantified the fault proneness of reused components as 74% less than that of newly developed components [8].

as reused components Selby considered those that were both modified and unmodified.


However, when considered with auxiliary operations, such as model generation and compilations, Spin model checking approach appears to be somewhat slower.

the model checking approach is indispensable for detection of many antipatterns, which are sensitive to the event order.


This case is hinting at a more general problem which is that vectorization can (and does) hurt performance in some cases: if the vectorization causes memory words to be read that are not used, and if memory bandwidth is already running at the hardware limit, vectorization can slow down the algorithm.

from our experiences, this seems to be a rare case.


Application developers/administrators can then compose these modules into specific policy engines without having to implement the engines from scratch.

with the sufficient flexibility of the policy engine architecture, modules that implement support for unusual factors should be easy t o implement and plug in.


In particular, none of the six pruned cases apply to A1, and therefore they have no effect on the result.


A client of a class has only to be aware of methods exposed by an interface of the class, and does not have to know the details of the class implementation.

the class can be modi.ed without the programmer being aware of the client if the class does not change the interface and its subclasses do not violate the Liskov s substitution principle.


For example, we have an SSH File adaptor for JavaGAT that uses the Jsch library [1].

we found that the encryption of the channel is inef.cient in this library.


We have also observed that some of these technologies were not initially designed to develop robots as a service or a set of services.

they have been used to the development of SORS.


The approach uses a sequence of synthesis and testing stages that uses heuristics to re.ne an initially mined automaton.

tAUTOKO mines typestate automata for JAVA programs.


The CLAM library [1], Loris [7], SPEAR [9] and AudioSculpt [4] enable spectral analysis and re-synthesis.

they do not o.er parametric control in combining di.erent types of transformed elements from multiple source sounds (see Figure 1).


4.2 Fast-tick Core Separating and Event Handling As mentioned above, the time consumption at Phase3 depends on domainU s scheduling delay, and Boost/Tickle mechanism of Xen Credit scheduler is a good solution to this problem when domainU loads only I/O-intensive applications.

xen Credit scheduler does not distinguish the types of tasks running on VCPU.


The IBM UPC compiler s front-end does not (yet) support the language extensions described in this paper.

an experimental version of our UPC runtime supports all array layouts, data distribution primitives and collective APIs described here.


6.2.1 Containment Con.icts The containment trees of the input models have to be merged in such a way that the merged version has a spanning containment tree.

the merged structure graph may not be a tree.


The selection criteria of programs de.ned for SWAB evaluation were that the programs were developing a new product or a signi.cant architectural change, a source of large expected revenues, a large resource investment, or a spearhead program.

only one new product was eventually included in the evaluation workshops.


The most straightforward method for reducing the computational burden is to split the input data set into batches and perform GC per batch.

this technique introduces batch e.ects that are an importantsourceof errors[19,27].


It can also be applied to other distributed applications, such as visualization, cooperative environments, or even consumer applications such as instant messaging, .le sharing, or online gaming.

many of these applications only require a very limited degree of connectivity.


If we had unique node identi.ers, we could use them to break symmetry.

if we focus on strictly local algorithms(with running time independent of the number of nodes), it turns out that we have the same lower bound p for the best possible approximation factor.


Because symbolic execution tool only changes the input bytes that are related to path constraints.

random testing tool changes a fixed fraction of input bytes to random bytes.


However, if the preallocation latency is too long (e.g., due to a too-large bucket size), an incoming synchronous request will be delayed increasing the contention at MMT and this delay directly adds to the critical path of program execution.

a too-small preallocation bucket size does not suf.ciently reduce communication and synchronization frequencies though it might keep the contention level at MMT low.


A potential reason for this is that it was by chance that the variantspecific defects could not be found.

this could be an indication that standard quality assurance techniques (as used in single system development) are not adequate to perform effective quality assurance in the context of software reuse and product lines, as discussed in Section 5.1.2.


Componentized language frameworks, coupled with variability modeling, have the potential to bring language development to the masses, by simplifying the con.guration of a new language from an existing set of reusable components.

designing variability models for this purpose requires not only a good understanding of these frameworks and the way components interact, but also an adequate familiarity with the problem domain.


http://dx.doi.org/10.1145/2643135.2643143 Over time, two distinct approaches to provenance have emerged: (1) the use of annotations propagated through database queries to illustrate where-provenance linking results to source data [7], lineage or why-provenance linking result records to sets of witnessing input records [16], or how-provenance describing how results were produced via algebraic expressions [21], and (2) the use of graphical provenance traces to illustrate how work.ow computations construct .nal results from inputs and con.guration parameters [5, 22, 30].

to date few systems formally specify the semantics of provenance or give formal guarantees characterizing how provenance explains results.


[17] have designed a .exible region system that does not require LIFO behavior.

the system is monomorphic and .rst-order; it is unclear how to extend it to support polymorphism or existential types.


Conceivably, code transformations such as superblock formation can be augmented to incrementally update pointer analysis results in a fully precise way.

this would mean that each code transformation would have to incorporate a pointer analysis component comparable in both implementation dif.culty and computational complexity to the original pointer analysis algorithm.


In the case of a high-aggregation workload, we found that DMR signi.cantly outperformed both LMR and GMR architectures since it avoids data transfer overheads of the input data.

in the case of zero-aggregation or ballooning-data scenarios, LMR outperforms DMR and GMR since it moves the input data to a centralized cluster, incurring an unavoidable data transfer cost at the beginning instead of at later stages, which allows the compute resources to operate more ef.ciently over local data.


At this point it is necessary to gain experience with a reasonable set of metrics (four of which have been proposed here).

our application is well suited to studying alternate metrics since there is a rich set of patterns that can be used to evaluate them.


A fact base is a managed collection of facts, similar to a traditional database.

listing 1: "Put" event via Speech 1 (Speech (word "put") (con.dence 0.81) 2 (user "Lode") (on 1305735400985)) instead of activating queries on demand, we use continuous rules to express conditions to which the interaction has to adhere.


Some current approaches [13, 15] provide systematic ways to deal requirements change.

all these approaches have problems dealing with the crosscutting nature of some initial requirements.


In general, as the oracle and SUT are both ultimately based on the same set of requirements, we believe that some kind of relationship can be established between the internal variables of both realizations.

in some cases, the model and SUT may be too different to allow for steering in all allowable situations.


The main idea is to evacuate chares from nodes which would be removed in case of shrink, and provide them to the new processes in case of expand [15].

chare redistribution by itself is insuf.cient since that leaves residual processes in case of shrink.


This indicates that in logreg the savings of our page sharing system are triggered by R object allocations with a size smaller than 1024 KB.

since the increase of the size limit reduces the number of objects handled by our optimization, its overhead contributes less to the overall runtime of the benchmark.


With the aforementioned approaches to modeling changes associated with variability, it is theoretically possible to derive variants of an SPL or SECO.

neither domainspeci.c or general purpose model transformation nor aspectoriented programming have a dedicated variant derivation mechanism.


This required a maintenance procedure that, in part, was facilitated by the Java compiler, because most model transformations were programmed in Java.

since fragments of model transformations must be evolved when metamodel evolves, this .gures a lack in our proposal that do not considered automatic techniques for co-evolution.


We identi.ed that session durations are heavy-tailed irrespective of whether or not the stream is non-stop vs short duration.

the shape of the tail is different (Pareto vs. truncated) for different stream types.


In addition, the isolation of the effect and the evaluation of the impact of any given factor within a large, complex, and dynamic project environment can be remarkably difficult.

we suggest that a purely simulation-based approach to experimentation in software engineering has weakness which, we believe, can be addressed by the use of simulation and empirical techniques in combination.


It is worth noting that in Oraclefp, some applications can execute to completion with only 16KB of memory, while others require at least 32KB.

the overall execution times using such small cache sizes can be up to 13 times slower than those of the best performing approaches.


Readers might wonder if it follows directly from classical serializability theory, e.g., [5, 28].

the classical result is about a single execution and states that if, in an interleaved execution of transactions (procedure invocations, in our terminology), every transaction follows, e.g., TL, then this particular execution is serializable.


Also UML is not per se appropriate to model variability.

it allows us to extend it with variability modeling by using the standardized extension mechanisms.


The automaton starts in location Initial.

if an event of type Eb occurs in location Initial the automaton remains in the initial location since Eb is not initiator in E. if an event of type Ea occurs the automaton enters location Composing.


For production purposes one should build a test suite that runs a comprehensive set of tests for all constructors and methods in the class without any interaction with the user.

at the time when students are developing the class hierarchy, it may be preferred that they can see and run the test for each method or a constructor independently of the rest.


All in all, design and software-security patterns share basic sections and it is possible to describe security patterns without using additional description sections.


This is because page migrations occupy a fraction of the memory bandwidth to PCM, which delays application memory accesses that happen concurrently under CPM.

the increased penalty is not large enough to o.set the reduction in stall cycles due to migrations.


In practice, there are several tools and techniques for managing such requirements [8].

there is still a scarcity of tools which support detailed analysis of requirements expressed in unrestricted NL [31, 17, 2].


The generated code, however, may be very large, since it grows exponentially with the number of bits of the quantization schema[21].

controllers synthesised by considering a .ner quantization schema usually have a better behaviour with respect to manyother non-functional requirements, such as ripple and set-up time.


The coordinator s greedy solution to the assignment problem results in suboptimal performance.

the V-Formation coordinator uses each individual peer s bene.t to arrive at a more ef.cient allocation of bandwidth.


On the one hand, they were applied successfully in a variety of challenging projects.

they are currently exported and adapted to other areas, including safety-critical medical processes which we are currently focussing on.


For example, AUML s multiplicity connector (denoted by a message followed by an asterisk) means that the message can be sent an arbitrary number of times and can be accommodated by an extension of our translation fairly easily.

preconditions require additional information that is not easily extracted from the messages: the debugging agent cannot know when an arbitrary condition becomes true since it doesn t have access to the internal beliefs of other agents.


In this case the speculative thread must determine if this is the .rst write to the node and thus the node must be copied into the speculative space.

if this is not the .rst write to the node, then the node has already been copied into speculative state.


Current term-based trace retrieval algorithms are incapable of understanding these concepts and would therefore be unlikely to precisely create the corresponding link [10].

most human domain experts performing the tracing task manually would be able to look beyond the mismatch of terms, reason about the concepts in the domain, and correctly establish a trace link between a source and target artifact.


The strictest fairness requirement is to find a perfectly periodic schedule with periods ~'i.

such a sched- ule is not always possible, as implied by the Chinese Re- mainder Theorem (for example, there is no perfectly pe- riodic schedule with Tt = 2 and ~'2 = 3).


Strict/weak consistency model, out-of-order access and execution issues Different memory consistency models may cause different memory access orders for the same concurrent program.


Using the cloud, our system can elastically scale up and down regarding the number of users and sensor streams for event processing.

there are two critical drawbacks for the cloud-based approach.


The semantics of Lazy-LL/SC is weaker than that of similar objects used by us previ- ously to design lock-free and wait-free constructions, and as a result can be implemented more efficiently.

we show that Lazy-LL/SC is strong enough to be used in existing non-blocking universal construc- tions and to build new ones.


These interaction conditions are called guards in computer science [26], since they control the signalling of the actions.

to determine the speed of convergence and termination of the BRBP, we need to use probabilistic arguments.


In this case, the comparison between the costs of the original and residual programs would be much more complex.

the current PE scheme also enjoys the following property: given an expression e, if the costaugmented LNT semantics computes the derivation (K0,e).


The Understand tool, like many fact extractors, is designed to work with complete versions of the system.

since the .les in the system evolve individually, we created monthly and transaction snapshots of each .le and ran Understand on each of these snapshots as if it were a static release of the source code (see steps 1, 3, 6 in Figure 1).


These 1-channel FTL schemes could use a small memory space and improve the performance.

they are not appropriate for a multi-channel architecture.


The channel processes carry the name of the type.

for simplicity in the de.nition of each channel we refer to it as the channel process K instead of, for example, SYNCHRONOUS.


Considering the mediansthedi.erenceintimebetweenthetwo methods is 10 minutes.

the di.erence is not signi.cant as the Wilcoxon test results in a p-value = 0.07.


There are many different parts in the entirety of the GHC pipeline, and some of the no.b programs have teased out otherwise undiscovered interactions between the pipeline and the changes necessary to enable the stack transform.

for the vast majority of programs, it is possible to apply our stack passing transform to the entire program, and still run it with a modest, but perfectly acceptable, performance hit.


D passing through thebottlenecklinksbetween E and F, consumingtwicethe critical resource.

consequently,themaximumachievable ratesofSimulcast andMutualcast are all120kbps.Celerity explores all 2-hop delay-bounded trees, and upon convergence utilizes the treesthat only consumebottlenecklinkbandwidth once, achieving ratesthat are closetothe optimal of240kbps.


With this modi.cation, we can show that at least one of the proposers will successfully complete its round and process its bu.ered values.

we cannot guarantee that all proposers will successfully complete their rounds and process their bu.ered values.


Thus, the synthesizer can transform the code into three barrier-separated phases: one each containing worklist.pop, process and worklist.pushmany.

since process neither reads nor writes to data-structure worklist, it can be executed in the same phase as worklist.pop (or worklist.pushmany).


Because tables are mostly stored in DBMS, many SPEs implement various input adapters like feeding data from DBMS and fetching tuples from DBMS using DBC interfaces.

for this reason, the Altibase DSM support the relational table feature that can be updated from the DBMS tables.


Each bar labeled `no zlib' compiled code is used to directly benefit the user by improving the execution performance of the programs.

the log is elapsed time of the compilations that performed the same used only for improving debuggability, while it reduces the optimizations in all executions for the base, `no zlib', and `zlib'.


Hence there is an advantage in that the lazy assertions presented here are limited to properties of algebraic data types that canbe checkedin linear time.Itisa limitation that simple equality checks like for the Boolean tuple in the introduction cannot be expressed.

such assertions can only be violated when data structures are fully evaluated, which may happen less frequently in programs that work with manypartial data structures (cf.


Compared to some of these models, the data model used by WildCAT is over-simpli.ed.

this was a concious decision on our part because we wanted to allow simple and most importantly e.cient implementations, without too much overhead.


[15] harnesses the compact thermal model to deploy a thermal-aware scheduler, which requires the complete temperature behavior for minimization without hurting performance.

the compact thermal model is simpli.ed to make its adoption viable outside of a simulation environment and inside the Linux kernel.


These platforms can meet tight timing deadlines, and thus provide real-time support for protocol designers wishing to test at line rate.

they su.er from another problem, which has seriously limited their adoption: these platforms are dif.cult to program.