de l Europe 38330 Montbonnot, France Pascal.Fradet@inria.fr Abstract Aspect Oriented Programming can arbitrarily distort the semantics of programs.

weaving can invalidate crucial safety and liveness properties of the base program.


2.1 Choosing a Store Given a Schedule Tile first problem is to find the optimal storage mapping for a given schedule.

we are given ® and choose m such that 1.)


Notice the dif.culty of updating the global heap, especially the part modf * modf .

using only the local speci.cation of find, one would not be able to prove that ¬y(f * )c. Indeed, the problem is updating the reachability of elements that are outside mod; in more complex situations, these elements may be far from the changed interval, and their number may be unbounded.


Note that the AK47 and M240 have the same caliber (7.62 mm), just as the M16, M4 and M249 do (5.56 mm).

the system is able to di.erentiate between weapons of the same caliber.


They are implicit, and hence called implicit dependences.

such dependences arise if the de.nition of a variableispresentin onebranch(letitbethetruebranch withoutlosinggenerality) but absentfrom the other(letit bethefalsebranch).


We concede that our high-tech prototyping attempt might have been just as unsuccessful as low-tech prototyping if we had started the former on a blank slate , as opposed to showing participants how they could import characters from the SC libraries and drag these characters around on a themed background.

it was likely that hightech prototyping resulted in more creative designs because it was based on the laminated cut-out model [24], which was effective in stimulating children to generate ideas for low-tech prototypes.


For a complex device in the physical layer, the corresponding node in the workflow can be recursively decomposed into a workflow of simpler nodes each of which performs relatively more primitive activities.

our workflow is a hierarchal structure [21] with subworkflows nested within composite nodes.


The right tools and techniques can make functional testing easy and cheap.

we recommend techniques for making functional testing fast enough to be in the continuous build (and at least as fast as the typical check-in cycle in a non-agile development environment).


LEMMA4.1.The power rate of task i, Gi, is non-increasing with i.

for any i1 and i2, 1=i1 <i2 =n, we have Gi1 =Gi2 .


Additionally, the library expander produces straightforward code amenable to optimizations like copypropagation and procedure inlining.

no runtime indirects are required to determine the values of either local or importedvariable bindings.To date, wehave tested the implementation under Chez Scheme, Chicken Scheme, Gambit, Gauche, Ikarus, Larceny, and MzScheme.


DIDUCE succeeded in identifying the root causes of programming errors in each of the programs quickly and automatically.

dIDUCE is effective in isolating a timing-dependent bug in a released JSSE (Java Secure Socket Extension) library, which would have taken an experienced programmer days to find.


To deal with doubly linked lists that are well-founded [14], we maintain reachability properties for the next .eld and the prev .eld separately.

we maintain di.erent VRVsets for next and prev.


Workflakes has adequately demonstrated the process- based software adaptation controller concept in the case studies covered here.

while the instrumentation and measurement facilities by themselves may reduce a feedback loop that was previously entirely manual from days or weeks to hours, Workflakes has shown that an automated controller can fia'ther reduce the consequently determined software adaptations from hours to minutes and seconds.


This ap- proach is based on three key elements: (i) formal program annotations concerning "mechanical" program properties, significantly extending ideas from [i0, 14, 13]; (2) maintain- able consistency between implementation and design intent via composable static program analyses, building on ideas from [22] and other sources; and (3) a step-by-step process for recording design intent and establishing assurance.

increments of assurance are obtained from incre- ments of effort in declaring annotations and policy, and in carrying out the analyses that relate annotations and policy with source code.


The code size increase, although noticeable, does not result in any performance degradation.

the measured L1 instruction cache misses were still extremely low.


In the second part of the paper, we take a closer look at the composition of two GLAV mappings.

we break GLAV mappings into a small number of well-studied classes (including LAV and GAV), and complete the picture as to when the composition of schema mappings from these various classes can be guaranteed to be a GLAV mapping, and when they can be guaranteed to be conjunctive-query equivalent to a GLAV mapping.


We iteratively identify the colored leaf nodes in the call tree.

we find colored nodes in this tree whose descendants do not belong to the set of colored nodes in any of the buckets of interest.


The comparison of the value obtained Hypothesis B: user performance depends on widget reprefrom this computation to the critical value shows that the null sentation complexity.

differences on users hypothesis (independence between participants) has to be respeed (efficiency) and accuracy (effectiveness) should apjected.


We explore the accuracy and the cover- age of these predictions and we propose a mechanism to take advantage of such run-time prediction.

we pro- pose filtering a victim cache so as to feed it only with blocks evicted as a result of a conflict.


We specify a loop reordering by a total order on T , ., and a bijection, C: T f ZN .

the codomain of C serves as the loop s iteration space, the domain of the loop control variable.


The use of implied scenario detection in security testing would be bene.cial to complement the limitations in the existing security testing approaches (Section 2).

the reason for why existing techniques are unlikely to detect these threats, is that existing approaches execute scenarios in sequential order.


However, such models insuf.ciently capture preemption.

the accuracy of preemption depends on the granularity of the timing annotation.


Thus, many methods have been proposed to allow non-serializable schedules that preserve some semantic notion of correctness.

several schemes allow users to specify that certain operations can be commuted with other operations; this enlarges the space of legal schedules, increasing the potential for concurrency [14, 16, 44].


Before a full buffer has been processed, the garbage collector cannot reclaim any of the buffered objects, thus leading to a higher number of objects alive at the same time.

for generational garbage collection, increased object lifetime can increase garbage collection time, because old objects are moved to the next generation.


It is di.cult to quantify this probability for an entire graph, so instead we focus on the probability of an individual error.

we de.ne an error as the realization of a single robust quad with one vertex .ipped or .exed from its correct location.


For this paper, our focus will be on the opposite technique of program factorisation [7], where a computation is split into separate parts.

we consider the problem of splitting a computation into the combination of a more ef.cient worker program that uses a different representation of data and a wrapper program that effects the necessary change of representation [10].


None of the data constructors are exported directly to the SPL user, the SPL module provides alternative smart-constructors that should be more convenient to use.

we d like to be able to take any Distribution Real and perform pseudo-random sampling from it in order to approximate the expected value.


In this paper we are interested in the minimum trip count of a loop.

we want to estimate this quantity conservatively.


In order to solve some of the problems mentioned above, several researchers proposed methods to measure the functional size of UML models.

some researchers (see for instance [7]) have addressed the application of IFPUG FPA directly to UML models, while others (see for instance [5] [6]) proposed UML measures that retain the principles of FPA, but do not strive to provide measures that are equal or comparable with IFPUG function points.


Nevertheless, we found that using the services offered by LinkedIn we could extract additional data points in the analysis process.

we used the discussion participants background such as years of experience, size of company and role to examine whether their views regarding example usage correlate to these factors.


The 32-bit x86 version of NaCl takes advantage of the segment registers to enforce most aspects of this policy.

by setting the CS (code), DS (data), SS (stack), and GS (thread-local) segment registers appropriately, the machine itself will ensure that data reads and writes are contained in the data segments, and that jumps are contained within the code segment.


for most d values the computation effort of both methods are the same, so the gap between their overall analysis time is small.


Assume that j/k throws ArithmeticException (division by 0) during the first iteration of the loop.

the execution of the original loop throws ArithmeticException.


However, if these transitions are taken as the observations in an HMM with a .rst-or secondorder hidden-state dependency, marginalization of the hidden state induces much more complex distributions over the branches.

the branch distribution does not have to obey the Markov property.


While demonstrating a new form of double genericity, this paper covers only one part of what is possible in a dependently typed language.

our codes do not extend to all inductive families and so we cannot represent all types that are available (see Benke et al.


Magnetic .eld is much more dif.cult to block than electromagnetic waves (at least within the spectrum range usable for positioning systems).

water, which is the main component of the human body, has no relevant in.uence.


1999), like the ability to capture and restore the run-time stack, which are not available in all environments.

popular VM s such as the JVM or the .NET CLR do not provide this lowlevel access to the run-time stack.


This implication leads to a trivial check for con.icts: version v1 of item i is concurrent with version v2 of item i if and only if v1[r1] >v2[r1] and v1[r2] <v2[r2] for some replicas r1 and r2.

the version vector de.nes a partial order over the possible update history of an item.


We propose to provide further supporting evidence by outlining some details of the SE framework we propose in terms of Figure 1 and, demonstrating that we can give the diagram a semantics.

all the objects and relationships and processes denoted by the diagram could be given exact, mathematical/ scientific definitions.


In contrast, Valgrind maintains virtual application state including the program counter and updates it after every operation translated from original application code.

valgrind emulates the application s execution while natively executing Valgrind s own code, while DynamoRIO natively executes either one or the other, context switching between the runtime system and the application process.


The .gure shows that for increasingexploration sizes, the analysis yields diminishing returns.

there is little bene.t in running the analysis withbudgets larger than 500 steps.


To prevent our PSO algorithm from producing MRs in degenerate forms, when both values of c1 and c2 in a particle are close to zero, we reset them to a new value.


After that, the plan can start the parent again, reducing the stopped time.

the plan can be viewed as a program and the planner is responsible for generating this program.


But we can use a bridge predicate to assert that, no matter what schedule is taken, the resulting set is semantically equal.

for objects set and set computed by two different schedules, the equals method must return true because the sets must logically contain the same elements.


With the introduction of requirement shocks starting from second semester of change, teams found themselves struggling to cope with the changes in requirements.

teams often found themselves caught between arguments on what and how changes were to be taken into consideration and who were responsible for them.


Typically, yards differ in size, complexity, topology and degree of automation so that each individual installation needs to be customized.

this case study includes the configuration of the yard jockey service (handling of shipping tasks, truck scheduling, etc.


An important common characteristic of all these approaches, including those focusing on sequencing (choreography) and semantics, is that they do not change the underlying WSDL service specification - they retain the core specification in its original form and add additional information on top of it.

they utilize the same basic operation signatures as WSDL, but add additional specification mechanisms to support the description of choreography and semantics etc.


6.2 Code Generation Implementation One property of an inset Pin is that tile(z) nPiter = tile(z) for all z .Pin.

constraints on the iteration space are redundant for any tile whose origin is in the inset.


bounded(t): A Get(key) returns a value that is stale by at most t seconds.

it returns the value of the latest Put(key) that completed more than t seconds ago or some more recent version.


The reason why we consider the over-hold size and hold duration of THP is that there are not enough resources which can satisfy the requirements of all service requesters.

tHP allows multiple service requesters to place tentative holds on one service (i.e., resource), but only one of them can use the resource in actual transaction.


Secondly, we interpreted these latent and expressed needs with a view to defining functionalities.

the design approach used here is a two-step translation process.


Additionally, the above package implements all operations on the local host with Java Runtime as well and all Ssh related actors can perform operations locally, too.

if a host is named local , no Ssh session is established to the local host but local operations are performed.


Agent-based systems require adequate techniques that explore their benefits and their peculiar characteristics.

there is a need for modeling languages for multiagent systems that explore the use of agents and other abstractions as first order modeling elements.


However, a working phase being replayed completes execution when all the tasks in that phase are complete.

the tasks at the frontier of a working phase need to be distinguished from other tasks.


Concretely, Aries characterizes code clones by some metrics, and suggests how to remove them.

aries tells the user which code clones can be removed and how to remove them.


As mentioned in the previous section, TARANTULA s suspiciousness score indicates the possibility of coverage criterion to contain faults.

a coverage entity with high suspiciousness might have high probability to contain faults.


The base algorithm has the advantage that because the transformation is based on local substitution rules, its results are easy to predict.

the .nal number of operations is roughly proportional to the number of diagonals in the original matrix.


For simplicity, we show only information that is relevant to the counter variable.

the DFG contains only vertices that modify or block on counter and all the counterlabeled edges between them, and the annotation is restricted to refer only to the variable counter.


This maps wells to the greedy design of the optimization algorithm.

the algorithm keeps attempting different transformations in a greedy loop that only terminates if no additional transformations can be applied.


This scenario happens when DSE could not cover all the dominant branches of tb in the method m. In this scenario, DynAnalyzer invokes ComputeDominants to identify dominant branches.

compute Dominants .rst identi.es the dominant branch, referred to as prime dominant, whose alternative branch is covered by DSE.


Continuing the same way, for each pre.x of idle intervals, we get that for any j, 1 = j = k, there exists an optimal schedule with total idle time at least Lj |Ii| till the end of Ij .

i=1 for j = k this gives the statement of the claim.


Of the 717 checks in which the model checking engine ran and completed with a de.nite result ( Pass or Error ), it iterated 5.63 times on average with a standard deviation of 11.21 iterations.

on average, .ve false errors (infeasible error path) were encountered and eliminated before the engine was able to complete a proof or .nd a feasible error path through the device driver.


As stated, Re.nement 4 does not apply in all cases in which it could.

it does not yet account for differences in behavior between synchronization primitives.


While such a solution is e.ective at querying policies, it does not provide support for change analysis.

encoding policies as full-.edged logic programs can potentially make the change analysis problem as hard as trying to di.erence general source programs written in richly expressive languages, a di.cult problem and one whose solutions would provide little insight to the policy developer.


Our results using these traces are consistent with our other results.

we found that when we consider only cache misses, the simpler predictors are close in performance to dfcm and fcm.


In this paper, we determine rotational speeds of disks and data layouts of arrays at an I/O node granularity.

when we set the speed of a particular I/O node, it means setting the speed of all the disks controlled by that I/O node.


4.1 Awareness Tool for Motorists As a proof-of-concept we demonstrated the usefulness of the OGD we have used for this paper by means of an awareness tools for a practical application scenario for citizens.

we built a geo mash-up for motorists in Vienna, i.e.


First, the preferences for each QoS dimension are modeled independently of each other.

the preference function for each quality dimension captures the user s preferences for that dimension independently of other dimensions.


Hence, one may expect the bound for the type class Shape to be suf.cient for applying intersectMany to any pair of shapes.

the type system could rest on the assumption that the default instance can be applied as a last resort .


However, our interest in tree transducers here is not the decidability of meta properties but rather the compositionality of tree transducers.

tree transducers are closed under sequential composition [27].


There were additional constraints as well.


Through the connectionPlugin interface, plugins can receive events relating to con.guration-level changes.

these plugins are noti.ed of structural changes such as components being added, removed, or replaced, connector blocking and unblocking, and changes to a con.guration s connectivity.


But to our advantage, software architectural models contain a number of explicit degrees of freedom for variation that a.ect quality properties, but do not a.ect the functionality of the system.

we only consider degrees of freedom that do not modify the interfaces used in the architecture.


5.4 Evaluation of the New Feedback Mechanism The performance improvements achieved by the LFS++ over the LFS solution [2], have been evaluated in isolation (disabling rate detection, to make the results more reliable) by using mplayer as a test application.

we mea- Frame Number LFS LFS++  Figure 13.


2.2 Knowledge Background The main purpose of the ASAP methodology is to provide a framework allowing the implementation of light and highly specialized immersive tools.

this methodology will encourage the reuse of previously gathered information or previously implemented modules in order to fasten the programming of new, and suitable, immersive application programs.


the graph of M and the constraints in M are satis.ed [12].

instances of a model are graphes in which (1) elements are typed over the elements in the model, and (2) constraints in the model are satis.ed.


Compiler Driven Data Layout Optimization for Regular/Irregular Array Access Patterns Doosan Cho Sudeep Pasricha Ilya Issenin School of EECS Department of Information and Department of Information and Seoul National University, Korea Computer Science Computer Science dscho@optimizer.snu.ac.kr University of California, Irvine University of California, Irvine sudeep@ics.uci.edu isse@ics.uci.edu Nikil Dutt Yunheung Paek SunJun Ko Department of Information and School of EECS Senior Engineer Computer Science Seoul National University, Korea Samsung Electro-Mechanics Co.,LTD University of California, Irvine ypaek@snu.ac.kr sunjun.ko@samsung.com dutt@ics.uci.edu Abstract Embedded multimedia applications consist of regular and irregular memory access patterns.

irregular pattern are not amenable to static analysis for extraction of access patterns, and thus prevent ef.cient use of a Scratch Pad Memory (SPM) hierarchy for performance and energy improvements.


As these classes are not dead classes, they have to be associated to one of the identified layers according to the values of authority and hub computed at the previous iteration.

in case a class obtained an authority value larger than the hub value it is placed in the bottom layer.


By designing some experiments on TCAS expressions and some randomly generated expressions, experimental results suggest that di.erent fault prioritization strategies should be selected depending on the particular testing constraints.

when test resource is limited and there is a risk that testing may be terminated exceptionally, the strategy that CCF and CDF have higher priority, should be adopted since it may yield a higher fault detection e.ciency.


Obviously some packages contain more than one cluster.

in this experiment, 89% of the identified clusters matched the packages.


2.1 Idea The basic idea behind our specialization is quite simple: we produce new de.nition rules for function f|S where S is type of its argument.

for type S, function f de.ned by f(...x :: T ...) = ...g(x) ... is specialized to the following f|S .


As an example, in Figure 3, the action to be exe cuted upon clicking the Sign in button on the Home Page is conditioned on the actor s role.

if the actor has the Admin role then the orange colored Admin Home Page will be visualized, whereas actors with other roles will be directed towards a blue colored Book Search page.


Novel Language Syntax to Enhance Readability White Space, Parameter Sets, & Control Structures Clifton Kussmaul Department of Mathematics & Computer Science Muhlenberg College, Allentown, PA kussmaul@muhlenberg.edu Abstract This poster describes the preliminary status of a project to investigate novel syntax features to enhance programming language readability.

we present sample syntax for the use of white space, multiple parameter sets, infix object specification, and programmer-defined control structures.


Designing the rules of a game is known as mechanism design.

an aim is to invent games that can be playable by rational players in socially bene.cial ways [6].


This idiom is fairly common in concurrent C programs.

a data structure is initialized privately to one thread before being shared among all threads either protected by a lock, or read-only.


ponent architecture to adapt to operating conditions.

these facilities support intercession ability of the re.ective application [3].


However, we introduce a re.nement operation to improve the localization accuracy of the system.

the position estimated by the location engine in case study three is not considered as the .nal estimated position of the blind node.


That is, the entities and relationships within our model, and the rich textual description, should be intended as base guidelines to be considered while designing B3G-SOM architectures.

the considerations within the textual description allow for a better understanding of the speci.c domain we are addressing and of all the challenges that must faced during the design process.


We can further improve the performance, especially the memory usage, by exploiting the connectivity of graphs.

graph vertices can be visited in a topological order of the strongly connected components (SCCs), and after a SCC is .nished, data structures containing information about that SCC can be de-allocated.


3.1 Research Questions 1A framework for collection and analysis of software development process data https://code.google.com/p/hackystat The central question of this study is the following: What is the relationship between the conformance to TDD and its observed e.ects?

we want to investigate the impact on external software quality, the developers productivity and the tests suite, in terms of number of tests that were produced, as well as their thoroughness.


(ii) Rule (E4) of Figure 7 is substituted to Rule (E4) where =k is a new relation which identi.es mathematically equivalent abstract expressions.

the relation =k is the quotient relation = / ~k where ~k is de.ned by:  I,k e ~k e I .. 'e,k = 'e.


Rcycle The rank function synthesis engine can prove this relation wellfounded, and returns the following ranking relation computed during the proof which over-approximates .1: T15(s,t) t(x) <t(y) .

t(x) = s(x)+1 we know that T15 is well-founded and that .1 .


From the perspective of player r, the bullet has initially delay d(r, e)= d(r, p), which reduces to d(r, e)= 0 when d(r, e)= 0.

player r perceives the bullet moving faster than its actual speed until it has passed the player.


However, other prior research [4, 16, 42, 36] has shown that the ef.cacy of a memory management system (the allocator and the garbage collector) is dependent upon application behavior and available resources.

no single collection system enables the best performance for all applications and all heap sizes.


Our optimizer performs this replacement while the MIR control .ow graph is built; therefore, it imposes zero overhead on the compiler.

instead of creating a virtual name for each parameter in the graph, we create a constant with that parameter s runtime value.


Extracting all variables from them leads to xA, xB, xC and, hence, to the classes A, B, and C as well as their UML constraints.

the designer is pinpointed exactly to the components which are responsible for the contradiction (according to the discussion from Example 1).


In their experimental investigation they evaluate whether using UML is profitable in a realistic context for a large project system.

according to them, all of the participants found the UML diagrams useful in terms of maintenance.


Software approaches that require exclusive ownership for writes to shared memory are closest to our approach, but they still use version-number techniques for reads [16, 2, 7].

one can view these approaches as locking on write but using optimistic concurrency for reads.


Now, the question is: Can the elements of the distance matrix be updated simultaneously?

must a[i,k] and a[k,j] be computed before updating a[i,j]?


MetaBorg also allows an embedded language to use an entirely di.erent lexical syntax, which is not the case for syntax macros, where lexical analysis of the macros is performed by the scanner of the base language.

this feature of MetaBorg is illustrated by the embedding of XML in Java.


The .rst property is that in a detected loop, there must be a memory-write instruction that uses indirect addressing.

a register is used to contain an o.set that partly identi.es the location where data is to be read or written.


All these algorithms should take decisions on the basis of present and/or future load conditions of the system resources.

we address the issue of predicting future resource loads under real-time constraints in the context of Internet-based systems.


We test different versions of GCC from 4.5.3 to 4.7.2 in order to evaluate the effect of NEON optimizations in our OpenCL and notice that there is a signi.cant improvement in the later version of GCC in terms of NEON code generation, which results in comparable performance level as our OpenCL.

the change in default vector size from 64 to 128 bit (in 4.7), the addition of support for wider in- AESEncr yptDecr ypt BitonicSor t  BlackScholes Bo xFilter (SA T)  CUTCP  HIST O SGEMM Bo xFilter (Separ ab le) 10.4 SPMV F astW alshT r ansf or m Flo ydW arshall Matr ixT r anspose STENCIL BT  EP FT  IS LU MG  Recursiv eGaussian Reduction 27.4 ScanLarge Arr a ys 64.7 SimpleCon v olution  SobelFilter URNG SP  1.412 Geomean  Geomean Bo xFilter(SA T) Recursiv eGaussian SimpleImage    BlackScholes Bo xFilter (SA T) ImageOv er lap Matr ixMulImage QuasiRandomSequence SimpleImage SobelFilter URNG Geomean OCL version ofSGEMMin Parboilbenchmarksbyhandand measure the performanceimprovementon Device A.


5.3 Solving Antipatterns Table 5 lists some of the solved antipatterns for the BRS software model.

two columns are de.ned: the .rst one indicates the antipattern type according to the Smith and Williams classi.cation; the second one instantiates the solution by reasoning on the PCM model elements.


Destroy Object destruction in this paper has a different meaning from the object garbage collection in the Java Virtual Machine (JVM) [11].

destroying an object does not necessarily mean that the object has to be garbage collected.


These relationships can be used to support the change impact analysis in the related entities.

we can infer which entities can be affected when some entity evolves.


We have collected datasets that contain the information on 120,550 torrents, 3,163,685 .les, and 14,822,261 users, which are comprehensively analyzed.

we focus on: (1) how prevalent content bundling is, (2) how and what .les are bundled into torrents, (3) what motivates publishers to bundle .les, and (4) how users access the bundled .les.


Many load balancing algorithms, such as [13, 11, 4], are attempting to minimize the variation between partition sizes.

they try to create a situation where nodes have equally sized partitions.


od retur n(vectorizable paths)  end In more detail the three steps of Algorithm 1 are: 1) is loop form vectorizable: In step 1, we determine whether the input loop is in a form suitable for vectorization.

we require that the loop must be regular (i.e., can be easily translated to a Fortran Do-style loop) and countable [16], where the number of iterations of the loop is known before entering the loop body, and all loop iterations can be counted using an integer index variable.


UNFITNESS The basic limitation of a programming language is that the context of the program cannot be easily programmed as domain problem solving does.

the context cannot be seen at the programming stage.


Each tester invokes the service under registration playing one of the roles speci.ed within the service policy.

each invocation of the tester to the service under registration includes a voucher that certi.es the role that the tester is playing.


The constraint generation process produces units that contain only the units appearing in their inputs (excepting error units).

both + and -+impose equality constraints on their inputs, while +* and +/ specify how to combine input units to obtain a result unit yielding append constraints.


However, our approach can be applied right away to software projects developed in other programming languages and paradigms that have suitable abstractions for modules and dependencies.

we assume that dependencies between JAVA packages represent the coupling between modules.


To mitigate this concern, this paper shows how to use automatically generated tree models [2] to discover the best con.guration of genetic algorithm-based approaches to reordering a test suite.

we use the binary recursive partitioning algorithm [2, 5] to construct tree models that reveal how the explanatory variables (e.g., the selection operator) impact the CE value of the resulting prioritization.


This algorithm is invoked, for example, by the type checker module when it examines assignment statements.

this algorithm is used by the type checker to verify that the type of the right-hand side value in an assignment is compatible with the type of the left-hand side variable.


However, that kind k 2 of variety is restricted to zero distances.

sTt = 0 j=1 xj |- µ2|, implies that all the count vectors for T are identical which k s = in itself restricts variety.


In this abstraction, communication links are perfect links (reliable channels), processes crash with a crash-stop behavior, and an eventually perfect failure detector is available at any node.

if no process at either end of a channel crashes, messages are eventually reliably delivered (not duplicated, not lost) and delivery is acknowledged.


In the future, we will look into ef.cient join point matching mechanisms.

a decision tree-based approach for matching join points against a set of pointcuts may potentially reduce the cost of matching.


Moreover, there are gateways that take charge of collecting data from the sensor network, and vehicles that move around the city and contact the gateways, searching for an available parking lot.

we have de.ned that vehicle requests to #events % mobility % communication A 2.7 × 106 98.5 1.4 B 5.6 × 106 98.5 1.3 C 1.4 × 107 98.5 1.3 D 2.7 × 107 98.4 1.4 E 6.3 × 107 98.3 1.5 F 1.2 × 108 98.2 1.6 gateways are scheduled by an Homogeneous Poisson Process with interarrival time being an exponentially distributed random variable whose mean interarrival time is equal to 5 minutes.


JTA targets the more restricted scenarioinwhich asingleTM coordinateslocally started transactions that may span multipleXA resources, butdo not involve other TMs or application containers.

jTA supports only transactions with a single branch.


Hiding those details opens the pos- sibility to new optimizations for Java.

we have discussed the benefits of using a block recursive organization of the array elements.


2.1.1 Trade-off Analysis The goal of this phase is to identify the design alternatives and their relative impact on the quality attributes.

for a given structural pattern in the source model, a set of possible 1 A metamodel is a specification model that describes the structure of the models in a certain modeling language.


We need tools that support the developer in inspecting clones by automatically opening the a.ected model .les and presenting the clone in a way that allows them to quickly judge the relevance of a clone.

such tools must highlight the commonalities and di.erences between the individual clone instances.


In [12], we discuss how DSH will issue a bundle of exactly four database queries each query yielding one of the ti to evaluate a DSH expression of type Q [Employee ].

dSH does not suffer from the n+1-queries problem.


But since session2 has not been migrated, the lab els are not used and the connection is solely identi.ed by the tuple [IP0, IP10].

packets belonging to session2 s connection will not have a label attached while packets belonging to session1 s connection will have label1 attached.


Thusweobtainthepredicted setof optimisations by computing: y * = argmax q(y|x * ).

(1) y we .nd the value of y thatgives thegreatestprobability ofbeing agood optimisation.


Based on the results of static analysis, the program transformation generates a modi.ed program.

the code at each proxy introduction site is modi.ed to actually create the proxy at runtime, and code is inserted at each coercion site to implement the proxy-to-non-proxy coercion.


However, this solution still places equal value on all pieces of source code.

the artifact-to-code mapping is done equally for the entire code of an artifact.


RESEARCH QUESTIONS We summarize the tutorial content by highlighting which role BPEL plays in software architectures that span across organisational boundaries.

bPEL allows the reuse and composition of complex services from existing services that are deployed and hosted in different organisational domains.


Based on the analysis we proposed two new disk schedulers optimized for SSDs.

sSDs have much faster read service times than the magnetic disks with the service times being almost constant, while write request service times are more complex.


Our framework only covers tracing algorithms.

since counts are only maintained from behind to in front of the wavefront, there can be no cycles of objects with non-zero counts.


We use Sun and Sauvola s [36] definition of context throughout this paper.

context is the implicit/explicit information about the environment, situation, and surrounding of two or more entities during their communication with each other.


Note that the de.ning axioms of the auxiliary predicates satisfy strati.cation restrictions that ensure the underlying satis.ability problem remains decidable.

the de.ning axioms of the auxiliary predicates may mutually depend on each other, but these dependencies are not cyclic.


Artificial classes contain only objects and they inherit all other class characteristics.

an artificial class ac contains objects that qualify to be in Linsta~c~(c), where c is the corresponding class in the hierarchy, a objects from L~t ..... (c) migrate ir~to Linst ..... (ac), and hence are still considered in Wi,~,t ..... (c).


We choose Facebook as a target, since it is one of most popular and largest online social networking sites nowadays.

we use the .ndings in [1] and [3] to characterize the network properties and to establish a relationship between geographical distance and friendship probability that matched the one that canbe measuredinFacebook.


The contents of the queue always remain synchronized with the position in the decision tree.

when a C-node is reached, a closure is next on the queue, and when a leaf is reached, the queue is empty.


However, we consider that this approach is not satisfactory due to the fact that the diagrams transformations are rather complex but independent of the semantic transformations and, therefore, they can be reused from one model transformation to another.

it is possible to de.ne rules to create and update diagrams such as UML class diagrams that are independent of the actual model transformations, such as the pull up and pull down method refactorings on UML class models.


: permits new use cases for data types ` a la carte.

it allows us to compose signature functors and thus data types more freely without giving up the utility provided by the subsumption relation.


The execution time experiment involved identification of state and execution of the appropriate behavior.

this will be the time taken from the play button is pressed, until the track starts playing.


It is known that each thread of highly scalable programs which favor additional cores is independent, having less communications between each other.

highly scalable programs can fully utilize the CPU time allocated by the OS.


However, there is one important difference: Java arrays are covariant whereas Scala arrays are invariant.

it is possible to pass arrays from Java code to Scala code.


Model monitoring (or explicit model monitoring): A1 and A2 are separately implemented, but maybe at di.erent stages of life-cycle.

a2 can be added or modi.ed at later stage of life-cycle.


In other words, the problem is not determining such a constant (e.g., as in [33,8]), but its very existence.

it is important to be able to predict whether a high-level control task can always be completed in bounded time, independent of the values of the variables involved in the computation.


In many applications establishing secure pair-wise communications can be useful.

it is a pre-requisite for the implementation of secure routing, and can be useful for secure group communications as well.


For Figures 8(a) and (c), nothing is done between each execution.

no form of explicit cleaning is performed.


Given a quorum system Q over U and an access strategy p, we can de.ne the load of an element u .U to be load(u) = .Q.Q:u.Q p(Q).

(this is the probability that the element u is accessed when using the access strategy p.) Given a placement f : U .V , we can extend this notion of load to any node v by de.ning load f (v) = .u.U: f (u)=v load(u).


We see a common element x in the classes of v1 and v4 and a common element y in the classes of v2 and v5 .

the intersection of classes of v1 and v4 is non empty and also the intersection of classes of v2 and v5 is non empty.


However, the steganographer is not free to choose which bit to .ip since it is determined by the wet paper and Hamming coding result.

it is possible for Pt to be changed into any PM in the set Kt = {P||w(Pt) - w(P)| =1},where w(P) is the Hamming weight of P. Since the PM modi.cation is uncontrollable, the embedding impact of Pi should be measured by the maximum cost of replacing it with any PM in Ki.


The service factory abstraction enables the con.guration executor to deploy heterogeneous artifacts [18, 25, 23].

servicefactoriesareavailableinorder toinstantiate,import, orweavethedescribedcomponent,service,or aspect, respectively.


According to the Table, Microsoft Word and PowerPoint 2007 suffer from security vulnerabilities caused by third-party components, which lead to remote code execution attacks.

loading the Google Desktop Office Addin and the HP printer driver fails to resolve particular DLLs when the programs open documents, and the current directory at that point is the same directory as the opened documents.


Since a monitoring station may be potentially receiving numerous status updates from multiple vehicles at the same time, buffering is used to accommodate such bursts in data traffic.

a remote buffer abstraction is utilized allowing the monitoring application to run more independently from the socket stream processing.


6.1 The evaluator corresponding to the CAM The evaluation model embodied in the CAM is an interpreter threading a stack with its top element cached in a register, representing environments as expressible values (namely nested pairs linked as lists), with a caller-save strategy (witness the duplication of the register on the stack in the meaning of applications below), and with a left-to-right evaluation of sub-terms.

the meaning of a term is a partial endofunction over the register and the stack.


Linking a fragment of polymorphic bytecode B,equipped with polymorphic type constraints G,ina givenclass type environment ., amounts to .nding a suitable substitution s mapping the type variables into class names.

the substitution s instantiates some polymorphic type constraints in G into monomorphic type constraints that hold in .,and instantiates variables in B correspondingly; these constraints can be eliminated, leaving only the constraints in G ' .when all constraints are eliminated, we obtain a fragment of standard bytecode (like the one produced by global compilation).


A natural question arises can we express mutability without mutable signals, or are mutable signals its necessary precondition?

can we express a mutable cell that produces events without mutable signals?


The Java source code of the CUT is analyzed and transformed by the Branch instrumentor module, which produces an instrumented version of the original class and determines information about method signatures, call and control dependences, used by other modules.

the Chromosome former is able to generate chromosomes based on the method signatures, and implements the mutation operators to transform them.


To achieve high structural coverage of the MUT (and the private methods calledbyit) needs various inputs.

to cover the code under the true branchof dbConfig.getAllowCreate in the setupDatabase method and create a new database, the .eld allowCreate of the DatabaseConfig argument of the MUT should have the true value, which by default has the false value and can be mutated by invoking DatabaseConfig.setAllowCreate.


On one hand, the component paradigm is a way of reaching this goal by enforcing the reusability of functionalities involved in a component-based middleware framework.

re.ection could be combined with components to improve the adaptability of the structure of their assemblies.


.s, and (2) if s(s1)= (s2, false), then s1 = s2.

a shared operation either returns true and satis.es its speci.cation, or returns false and does not modify the shared state.


Specifi- cally, if A~ denotes the actions available to attacker i, then the joint action space is A1 x A2 x ... × An.

a joint action is a combination of all individual actions taken at the same time.


An edge connects two nodes if the register classes of the candidates represented by the nodes alias and at any point in the program the candidates are simultaneously live.

interference graph edges identify those candidates that cannot be allocated to registers that alias.


They use the boolean reference b as lock in the incrementing function.

once this function is called the value in b is set to false and only after the call-back is called and the value in x is incremented is b set again to true.


Figure 2- Architecture of the Odyssey Mediation Layer The OML engine is part of a reuse environment, named Odyssey, that deals with component based development of applications within a given domain.

oML is part of a system of agents that helps users in their search for reusable components [16].


This will help them understand team progress and to react to it appropriately, e.g., by applying the teaching styles suggested for each stage by Tuckman.

the model may help educators to distinguish between normal difficulties in team development (e.g., in the Storming stage), and team difficulties that are abnormal and may require intervention by the instructor.


Moreover, it also disallows (Q,as0 ,Qd)a s0 when t is a variable a: variables with non trivial bounds must be treated abstractly and cannot be silently expanded.

(Q)V(as0 ,ad s0 )a -adV(as0 ) a -a does not hold.


For developers, the NEWT platform also makes it easy by automatically wrapping responses and converting them to the standard NEWT envelope format.

when implementing access for a new resource, the adapter does not need to adhere to the envelope format because the base code of NEWT will do it automatically.


This can be captured in terms of a type function Delta, such that Delta s a b is the type of one-hole contexts for sab.

a value of type Delta s a b is equivalent to one of type sab that is missing one value of type b; so the type functor should be equipped with the corresponding operation to close a Delta s a b around the missing b to make an sab.


If a hypothesis of a rule contains wildcards, we introduce an auxiliary relation to hold only the non-wildcard arguments of the hypothesis.

for every hypothesis of a rule that contains wildcards, we (i) replace the hypothesis, say P (X1, ..., Xa), with a new hypothesis, Q(X1, ..., Xa/ ), where Q is a fresh relation, and Xk s are the non-wildcard arguments of P , and (ii) add a new rule P (X1, ..., Xa) .


There is still redundancy in our representation.

prev pointers have spare bits that can be used for example as extra .ags by a more sophisticated garbage collector or by a JIT compiler such as Schilling s [44].


The varying experiences of the participants may inevitably impact the results of our case study.

one engineer in Group AHR did not remove defects when reading code and also had only one defect in three modules, which is outstanding from other engineers.


For generality, we have studied type projections in the context of a canonical language de.ned around a value notation, a type language, and a relationship of typing between the two.

we have chosen a selection of structural types commonly found in existing procedural languages: built from a set of atomic types, they include include record, collection,and untagged union types, possibly recursively de.ned.


Any such tuples with the same pIP and pQID represent a duplicate answer.

a client answered the same query more than once.


However, these O's would have to be taken from the original 0 t bits in so, in order for the path to be geodesical.

it would be needed that £ > n -2t, which is not true in this case since l  4t.


The advantage of this simplistic model is that it makes it easier to understand the significance of simulation results.

we use a Bernoulli distribu-tion to model resource availability: for each binding request, a resource manager produces two outcomes, failure with probability p or success with probability 1-p. For this model, we assume that a component is served by a resource man-ager, the only owner of resources, and that the behaviors of all resource managers are independent of each other.


Among the different classes of mashup available on the Web, we focused on News Mashups [9] also known as Syndication Feed Mashups since they use syndication technologies like RSS and Atom to aggregate news related to various topics and create personalized feed views.

we envisioned the opportunity to aggregate feeds about personal information originating from social networking sites in order to foster group awareness within distributed teams.


Up until this point even providing simple statistics such as the number of data points available in our data sets had proven time consuming and troublesome.

the move to Cassandra now allows us to develop services that will analyze and index our datasets in parallel.


Another undesirable generational buffer and a unified circular buffer, which translates side is that they only applied the technique in user defined calls into significant speedup.

the adaptive scheme where source code is available.


Acknowledgements This work, and the PROBE framework in particular, was motivated by discussions by the participants at the PASTE 2004 workshop.

atanas Rountev and David J. Pearce provided suggestions both at the workshop, and in subsequent e-mail discussions.


On the engineering side, we are working on scaling up the Boomerang implementation to handle large datasets such as fullsize (1Gb) UniProt databases.

we believe it would be useful to have an algebraic theory of program equivalence for qlenses as a basis for an optimizing compiler.


Given a body of papers, a network can be constructed where the vertices (nodes) are the authors, and the edges (undirected links), represent coauthorship relations between the authors at either end of the edge.

if there exists at least one paper jointly written by two authors, there will be an edge in the network between the corresponding vertices representing the authors.


However, as we explored the range of ways in which people used the tool, and the set of extensions that they proposed, we found that it might provide value too as an analytic tool.

as users asked for mechanisms that would help them explore the structure of the system with finer granularity, we noted that these structures might also provide the basis for an archeological exploration of a software repository.


Other parts of the superclass may rely on the abstract declaration in their implementation, which enables us to express a computation which cannot be performed before the missing de.nition has been provided just like the body of a lambda expression cannot be (fully) evaluated before the formal argument, a variable, has been replaced by the actual argument, a closed expression.

virtual features of a class are in this sense arguments.


Figure 18: Qualitative Analysis Results for Java, AspectJ [6] and Eos  We also studied the size of the pattern implementation in both Eos and AspectJ.

we report on the size of the reusable part of the pattern in Figure 18.


) .3= tg} (6) where A ' = Ai[xi/this] Ai = Invariant(.i .class) (7) i On the other hand, from (G1) and the de.nition of Ver(Prog), for each one of the Ai we have: SF(Ai ) (8) From (8), de.nitions of A ' and lemma 8 we have: i SF(A ' ) (9) i From (9) and property P8 we have: SF(*(A ' )) (10) i Furthermore, we know that: t0 = tg (11) Since tg is the ghost thread that does not take part in execution.

we cannot have: ' H, ., (e0,tg,s0)(e ,tg ,s ' )|(en,tn ,sn), H ' , . '


We use an idea from Section 2: we attach a pyramid-shaped layered 6 quadtree on top of T .

let T be the graph that is arranged in layers z = 0, 1, .


In [5], the authors combine probabilities and situation calculus-like formalization of actions.

they not only define the actions and sequences of actions that constitute an intention, they also state which activities cannot occur for the intention to be valid.


For simplicity, we assume that neither H nor any preconditions of f in T ' (f) have existential quanti.cations.

the abstract run of y:=f(e) searches for a collection of specs of f stored in T ' (f) that can be used to transform the current symbolic heap H. for each spec {P }f(x){Q} in T ' (f), it tries to match the precondition P with the assertion H at the call site.


Such partially leaked data must be handled quite delicately.

if y is ever used in a conditional branch, as in the second conditional of Figure 1, then the permissiveupgrade strategy still gets stuck in order to avoid converting a partial information leak into a total information leak.


To copy otherwise, to republish, to post on servers, or to redistribute to lists, requires prior speci.c permis added to the workload?

we wish to verify the IPC results of previous studies to see whether they were overly optimistic by excluding the OS.


Transparency to guests means that guests must not be able tell if they are executed in a virtual machine or not.

cE is transparent if the state-transition function dCE that models CE is semantically equivalent to the function dCP that models CP .


A PROOF OF CONCEPT EXPERIMENT: ANALYSIS OF A COMMERCIAL UMTS CONNECTION In these experiments we show how it is possible to perform a simple analysis of a UMTS link using PlanetLab nodes and the tools we developed.

we equipped one of our PlanetLab nodes with a commercial UMTS connection provided by one of the major operator in Italy.


For a, there is an in.nite sequence of sets of system events that satis.es this modi.ed speci.cation.

following this modi.cation, a is no longer a counterexample.


Indeed, we have written a book identifying and examining as many as we can, and suggesting resolution strategies, where possible [24].

while this is a vision, and therefore necessarily incomplete, we think it is close enough to reality to start guiding the way we think now.


In many cases concurrency is an optimization, rather than intrinsic to the behaviour of the program.

a concurrent programs is often intended to achieve the same effect of a simpler sequential counterpart.


From this table, for each scienti.c function, the number of 1-MRs is from 0 to 353, whereas the number of 2-MRs is from 0 to 401.

our approach infers an unignorable number of 1-MRs and 2-MRs for scienti.c functions.


Even the OpenStack framework [10] is looking at the possibility to federate two or more OpenStack clouds.

openStack initiative, is investigating on Inter Cloud Resource Federation Models as described into [11], where the InterCloud Resource Federation Alliance is formalized.


Membership matching assigns clusters to halos based on the overlap of the member galaxies.

a cluster matches a halo if the plurality of the clusters galaxies overlap a single halo and vice versa.


A corpus used as input to a source code retrieval technique typically consists of method-level documents.

each document in the corpus corresponds to a single method of a software system and contains the terms extracted from that method.


Sharing complicates matters, since the system must provide guarantees as to which process or processes the shared objects will be accounted.

if custodian A and custodian B both share a reference to x, the Figure 1: Custodians and threads.


Consequently, all type declarations, constructor calls, and wrapper recycling calls for virtual types/classes within a CI are actually always annotated with an instance of the enclosing class.

type declarations and constructor invocations are always of the form enclInst.MyVirtual x, respectively enclInst.MyConstructor().


Each link, which associates a pre-activity with a postactivity, will be assigned a unique id called tag.

pre-activity and post-activity are the producer and consumer of a tag, respectively.


Cyberorgs may pre-pay to buy resources which will exist in the future.1 Cyberorg b may use the resources it owns only if the resources exist at a time when the cyberorg is being hosted by a.

after signing a contract, a cyberorg must migrate to the prospective host cyberorg in order to avail itself of newly acquired resources.


To support multiple domains within our VF, our framework supports pluggability (i.e., user-defined functional extensions).

it is possible to define in our VF domain-specific extensions to our testable model, such extensions (called plug-ins) still enabling their automated instrumentation in an IUT.


In the following paragraphs we analyze how the new features of HTML 5 contribute in facing the most important limitations of mobile devices reviewed in Section 2.

we present some of the most important features of HTML 5 under specific categories and their contribution in the deployment of web-basedmobile applications.


In this case, the formula is valid and the strategy is .x y,thenset x to the value h(y) .

with the new algorithm, new tests are derived from validity proofs, instead of satisfying assignments as usual.


the n th element in pre-order should not be further away than O(log n) elements from the root of the structure.

if such a structure contains a suspension in place of an element at position n, there will be no more than O(log n) partial applications on the stack of the corresponding partial result.


Assuming that trusted() returns false, Q has a transition sequence with labels t1:print site 1 , t1:(), t2:print sandboxed: , t2:(), t2:print site 33 , t2:() It is worth emphasising that without delayed instantiation, rebinding in these examples would not be possible.

in both cases the construct-time (let) rule would substitute out here0 in t1 before sending the lambda-term, thus preventing a rebinding of here at the remote site.


An important conclusion from these sensitivity experiments is that our approach performs better with larger number of cores, larger number of memory controllers, increased row-bu.er sizes and reduced last level cache space per core (not the cumulative LLC size), all of which are current trends in computer architecture.

we can expect our optimizations to continue to be e.ective in the long run.


The arraylets are designed such that these calculations only need integer division and remainder.


Finally, we want to study the impact of a particular kind of build system ownership on the kind of build system changes performed.

we want to know for example if Corrective changes happen frequently in collectively owned systems (which might be risky since there is less quality control), or if they only enter into the version control system via a dedicated owner.


We discuss speci.c theories that are relevant in program veri.cation and that satisfy this criterion.

we obtain complete interpolation procedures for theories of arrays and linked lists.


FILTERING ERRONEOUS USER INPUT An organic localization system is expected to encounter some level of noisy user contributions.

users will not always indicate the right room when they are prompted tomakea bind.


Note that the Hismo model is dual to the FAMIX metamodel.

if there exists a relationship between two entities (e.g.


5 that as demand for new contents increases, the utility again declines.

as the system is requested to carry more contents through, the limited bandwidth o.ered causes more playback disruptions.


In this context we can find a classic problem of information security related to the integrity of the communication channel, namely how to ensure that the Stego Video that was sent by the source user is really the same Stego Video received by the user destination?

we intend to prove that the video/document was not changed during its transmission by the communication channel or in the server.


3.1.3 Parallelism based on Replication Shared data bus is that multiple SIMD units share the same data bus.

all SIMD units can get the same data vector from the shared data bus each cycle.


If hash value is unpredictable, then tamper response is unpredictable as well.

created tamper resistant software prevents attacker s analysis and modi.cation by generating unpredictable self destructive tamper response that varies from modi.cation to modi.cation.


In the multi-threading context, our shadow variables for local variables and function parameters are still safe because they are local to each individual thread, while the soundness of shadow .elds depends on whether race condition vulnerability is present in original bytecode programs.

if the accesses to static or instance .elds are properly guarded to avoid race condition in the original app, the corresponding operations on shadow .elds are also guarded because they are placed in the same code block.


Implementing the EntityManager interface by means of aspects, we can offer several implementations, e.g., a highly efficient but restricted and a full-fledged one.

users can select a desired implementation easily by using the corresponding aspect.


Similarly, technology for collecting, analyzing, and predicting a user s movement path is also useful for providing adaptive services.

if questions such as Where is Mr. Doe headed now after leaving home at 9 a.m.?


The procedural mechanism for constructive negation is designed not only to generate every correct answer of a goal, but also to detect failure.

in spite of the bottom-up nature of the calculation of literal answers, goal computation is not necessarily in.nite.


We do not allow mixins to set parameters of the superclass constructor.

template constructors of mixins always have the following form: f .


Any model would produce a sound type system and allow us to 5By appropriately we mean that it must comply with the intuitive behaviour that we had in mind when we introduced the extensional interpretation.

it must be such that f v : t ..Hf v :¬ t. 6For instance, let us consider the recursive type t =(0 .


XML was designed to facilitate the creation of automated parsers rather than to make XML documents easy to read and understand by a human.

the opening and closing XML tags often obfuscate the described data values and their relationship to one another.


We limit our approach to static service composition only.

every called operation is predetermined by the program without involving service discovery and lookup.


We show that on average (over the choice of S) there are ft(n) indices i in {1,... ,n} such that there is a q-tuple in S which is good for i.


A dynamic type check may only be necessary for establishing a connection, not for every transmission.

we want to avoid transmitting repetitive type descriptions with every single value (in Section 3.2 we brie.y mention proxies as an example of such a mechanism).


This section examines the use of this architecture in application scenarios.

we explore the use of EVPath to: implement the event transport functionality in a di.erent publish/subscribe system, ECho[10];  implement peta-scalable I/O interfaces through in-network staging.


A FRAMEWORK IN ACTION An object-oriented framework for Web services like cxf contains two layers, one dedicated to objects, the other to services.

the object layer de.nes the interface between the user-de.ned object model and the service layer, while the service layer endorses the interaction via Web services.


A central issue is at what point in the data lifecycle should provenance marks be embedded.

note that raw sensor data is usually obtained as a straight voltage reading or as a ratio to a benchmark voltage.


DiSL provides all necessary language constructs to express the dynamic analyses that could be speci.ed in the DSAL.

in the future, DiSL can serve as an intermediate language to which the higher-level DSAL programs are compiled.


Now consider putting all 128 bits of a SIMD register to work in our character scanning application.

suppose that we simultaneously calculate whether or not each of the next 128 bytes represents an opening angle bracket, storing the result as a sequence of 128 onebit results in the register.


Some important built-in axioms are given below, where denotes don t care : .e(A, B)= .e(evale(A, 0),B) evale(.e(A, ), 0) = evale(A, 0) evale(evale(A, B),C)= evale(A, evale(B, C)) passe(true)=0 passe(.e(true, )) = 0 passe(.e(false,A)) = passe(A)+1 One of the bene.ts of having a well-de.ned semantics for primitive PEG functions is that we can reason formally about these functions.

using our semantics, we have proved all the axioms presented in this paper.


The effect of this choice on the algorithm s results is that its abstract types always correspond to unions of whole value interaction sets, rather than parts of interaction sets.

if a variable x had a value vx at # Global union-.nd structure for value interaction sets UnionFind value uf # Per-site union-.nd structure grouping value interaction set # leaders for sets of values whose unions form abstract types UnionFind type uf # Per-site array picking out a set in type uf corresponding to all the # previously-observed values of a variable Tag[] var tags  # Update the abstract types for this site, based on an execution when # the variables had values whose interaction sets are given by new tags method site.update types(Tag[] new tags): 1. for each variable v: 2.


The PolicyMgr can be viewed as just another client of the Cimbiosys API.

the API contains a noti.cation mechanism that calls clients when an item changes.


We have implemented and evaluated a simple strawman approach, which is to save all device state on failure using the existing support for putting the system in a sleep (S3) power state.

we simply use the system s ACPI suspend/resume functionality to save and restore system and device context to memory, while relying on the NVDIMM support to retain the in-memory saved state.


SYSTEM MODEL Although we seek to develop a general framework for constructing a range of cooperative services, our approach is guided by a speci.c problem in a speci.c set of environments.

we are building a cooperative backup system for three user communities: 30 co-workers who cooperatively back up their personal home machines, 500 students in a dormitory who cooperatively back up their personal machines, and 50 nonpro.t organizations that receive free or low-cost refurbished PCs [32].


[1,m], the edge ei exists in the graph throughout the interval [ri,ri +e-1], and ii) .i .

[1,m-1], ri+1 = ri + e. a transient path is e-stable if each hop exists for e consecutive rounds, and no two hops round intervals overlap.


RT-DVS algorithms, often integrated with CPU scheduling, derive workload from worst-case CPU demands of realtime applications [27, 28].

they set CPU speed based on the assumption that applications require worstcase CPU resources.


These modules (system wrapper and state-space explorer) are unmodi.ed when plugged into DEMETER.

dEMETER is able to leverage eMC s state-space explorer because it adds a partial-replay local system layer that gives the state-space explorer an illusion of a stand-alone complete system, similar to the original application.


For parametric image, the chosen parameters are not projected out of the image.

if one needs data accessed for a given set of outer loops through an access function M, the outer loops are to be treated as parameters just like other program parameters appearing in loop bounds, and M is used as the function for the image operation.


Using FayLINQ, this query will also be executed in an ef.cient, optimized fashion.

counts will be aggregated, per CPU, in each of the operating system kernels of the cluster; per-machine counts will then be aggregated locally, persisted to disk redundantly, to multiple machines for fault-tolerance and .nally aggregated in a tree-like fashion for a .nal query result.


This test unlike the other two seemed to have coordinating byte-hit and hit rate performance changes.

there was a positive correlation between changes in hit rate to changes in bytehit rate.


The structure of f *requires m to be a monad, and f to be a m functor.

we use this fact so often that we will use the following convenient notation for the required type constraint synonym: type f f*= (Functor f ,Functor m,Monad m) m this constraint expresses that f*is a well-formed m free monad transformer.


A variety of scheduling disciplines have been implemented, ranging from simple, traditional (e.g., .xed priority, EDF), to Time-Utility Function/Utility-Accrual (TUF/UA) policies.

we demonstrate a combined TUF/UA scheduling and thread integrity mechanism for providing bounded-time, end-to-end thread failure detection and recovery.


The trace interleaves a trace of the build s commands with a trace of their interactions with the .le system.

we assume that all of the e.ects that matter are recorded in the .le system, which is a reasonable assumption for most builds.


The proposed system modeling methodology is specifically suitable for DSE [3] since it makes it possible to describe a design space.

instead of a single system, the model represents the set of design alternatives to be explored.


Therefore, A0 provides the infrastructure upon which to construct semantic relationships among different ADLs.

it acts as a bridge among the different architectural languages to be related together.


To satisfy this requirement, all the previous proposals assume that user data resides on users own devices or devices the users trust.

user data is distributed across a potentially large number of client devices.


The main di.erence between Korat and our glass box model checker, however, is that Korat ultimately works like a black box model checker.

korat generates every valid state (within a bounded domain) and checks every operation on every state.


A careful inspection of these two CSRS s and of their interaction shows that the duplicating R-rule is not a problem any more regarding non-termination, because the .rst two occurrences of x in the rhs of the R1-rule become blocked after applying the rule.

any further extraction of subterms at these two positions, that is crucial for Toyama s counterexample to work, is prohibited by µ(f)= {3}.


This requirement to overlook failures and the very means with which failures are presented are in most respects dependent on the way this project is organized.

a fix is not always urgent in this project and is sometimes best left to or coordinated with others.


3.4 Memory Mapping for Hypervisor/VirtualMachine Realms To support strong memory partitioning between multiple hypervisors on a single platform, we propose a physical memory remapping mechanism.

physical memory space is divided into chunks of equal size (e.g., 8MB).


Dispatching.EDF It is obvious how to exploit this interface to program either periodic or sporadic task.

a call to Delay Until And Set Deadline() delays the calling task until time Delay Until Time.


In DMdA, the list prints as #, and the ant prints as #>.

this has the technical disadvantage of not being usable as an expression, but also prevents certain abstraction violations: it prevents students from cutting and pasting the result directly into a test case.


At this point we are in a similar situation as the one depicted above for the case of read access to remote data.

for the preparing transaction, the framework logs the identities of the contacted servers, and then waits for the occurrence of prepare reply simulation events scheduled by any of these servers.


In contrast to these related works, our approach speci.cally targets architectural abstractions.

we have designed our DSL to only require changes of the DSL code once the architecture of the underlying software system has changed, but not for other kinds of changes.


Treatment novices did not do much worse than Treatment intermediates and experts.

for the Control group, bugs found ranged from 1-9 and bugs fixed from 0-6.


«interface» Client_management + Add_new_client(string, int, string, string, string) : string + Update_client(int, string, int, string, string, string) : void «WriteOp» «RW_Op» «interface» Financial_management «WriteOp» + Record_payment(int, date, date) : string «ReadOp» + Payments_due() : void + Record_payment(string, int, string, string, string, date, date) : string When modelling complex applications it may happen that some use cases represent several transactions.

use cases represent functionality at a higher level than the one required for FPA counting.


The formalization of RVE is defined if there is a given code element that belongs to the current version of the feature mapping (j) but it does not belong to the previous one (j-1) or to the next one (j+1).

this element is not present in the entire horizontal history of the members and vertical history of the program family.


Non-volatile main memory (NVRAM) can alleviate this problem, but current software models for using NVRAM have limitations.

user-level persistent heaps, while outperforming blockbased NVRAM, still have high overheads compared to in-memory operation.


So, the capacity of the source is set to Cs = 3 and a client s capacity to Cc = 4.

the 1http://www.omnetpp.org/ 2http://www.omnetpp.org/doc/INET/neddoc/index.html Figure 3: Resulting join rate in the simulation.


To prove this result, it was necessary to revisit the definitions of some basic concepts that were .rst given in [5, 4] (e.g., what constitutes a problem, what it means to solve a problem, what it means to implement a failure detector, and what it means to compose an algorithm that uses some failure detector D with an algorithm that implements D).

we augment the model in [4] to allow external input and output actions.


In this paper, we propose an e.cient victim block selection (module) design to improve the performance of the existing garbage collection policies by minimizing the time on (1) selecting the victim blocks with maximal invalid pages, (2) identifying the status of each .ash page, and (3) copying live pages from the selected victim blocks.

a victim block selection strategy is designed to recommend the best victim blocks (i.e., the blocks with the maximal number of invalid pages) and page status of the selected victim blocks for the existing garbage collection policies with limited accesses to the .ash memory, such that the victim block selection overheads and the live-page copying overheads could be minimized even when the storage capacity grows.


1.1 Vital The Vital project[12] aims to combine the complementary strengths of these two, very di.erent, classes of declarative language.

it seeks to combine the expressiveness, clarity and soundness of Haskell with the direct data display and liveness of the spreadsheet.


While those studies have shown promise, they have an unrealistic assumption that the huge power demands of data centers have no impact on electricity prices.

data centers are treated simply as price takers in the power markets and their electricity prices are assumed to be irrelevant to their power demands at a given time point.


We assume that the process failures and the scheduling are controlled by a strong adaptive adversary.

the adversary knows the results of the random coin .ips that the processes make, and can adjust the schedule and the failure pattern accordingly.


the features added by MetaOCaml to OCaml) to a single module.

the software architecture for our generator is mostly driven by mathematical clarity, elegance and generality.


BJ Ö R N : The compile function is compositional because there is one case for each constructor and each case deals with exactly one constructor.

the constructors Return and Bind are handled completely separately from all other language constructs.


Given a reference p to a Person object, we ideally want p s account , i.e., a compound, or indirect reference to account via p, to be passed to SOP, rather than the account reference itself.

we want some kind of redirect semantics for references: the meaning of account should be Figure 2: Decorator design for output streams late bound within the current context of the object referred to by p, whenever p s account gets evaluated.


An often-neglected point is that the solver must co-operate with the rest of type inference.

the constraints may mention uni.cation variables, and the constraint solver may .x values for some of these variables.


These types of bugs are di.cult to .nd because they break the programming language abstraction.

the semantics of the programming language do not specify what will happen; instead, the underlying implementation must be examined to determine what is possible.


Yet, it is an area that provides an interesting and challenging basis for programming language research.

the fact that almost all operations are based on time-varying quantities (indeed, time is a critical factor) in most algorithms o.ers new and interesting challenges to programming languages.


Due to features such as differential and pulsed current-mode signaling, these channels have power pro.les that are invariant to utilization.

these communication channels dissipate substantial power even no data is being transmitted.


In mobile environments (especially in the case of the most extreme scenarios), synchronous communication mechanisms appear to be not suitable, since these assume that the involved entities are present at the same time during the interactions.

they consider disconnections as failures, whereas these may be the norm rather the exception.


The adoption of the Semantic Web standards for representing context data is fundamental to guarantee a common understanding among devices and services, enabling interoperability.

we intend to use the Linked Data standard [5], which is based on the representation of data in the form of RDF triples, using standard vocabularies  such as DBPedia, FOAF, Geo, GeoNames, etc to represent context data types and instances.


It means, for example, that a requirements model is an aspect if it crosscuts other requirements models (or simply, a requirements artifact is an aspect if it cuts across other requirements artifacts); a design model is an aspect if it crosscuts other design models.

a use case (defining a set of requirements) is not necessarily an aspect.


The two possible decision trees for example 4 First row f Heuristic f favors columns i such that pattern pi 1 is a generalized constructor pattern.

the score function is f(i)=0when pi 1 = , and f(i)=1otherwise.


SM is known to perform well in simulation studies of multiprocessor scheduling [7, 1] but unfortunately no formally proven results are available and it has not been analyzed for uniprocessor scheduling.


However, the information-hiding decision process does not account explicitly for the costs and benefits of modularization, so it does not help designers most effectively to design for value added.

the current formulation does not address two key questions from a value-maximization perspective: (1) which of the available modularizations is best; (2) at what point should one be selected in the face of uncertainty about the first question?


Semiotic Engineering perceives HCI as a designer to user metacommunication.

a twofold communicative process, because the designer to user communication is achieved through user-system communication.


The RMedSE computes the median value of the transfer error for the first and second image [19, 17].

the transfer error defines the Euclidean distance between projected points from the first image and matched points from the second image by the affine matrix H and vice versa: .1 .


Their relation with a type hierarchy and how they can be designed and implemented properly in a type hierarchy is described.

the relation between type-incompatible equality and subtyping is discussed.


One immediate observation is that visualization may be of little use if packaged with an environment that increases cognitive load because the reduction in cognitive resources provided by the picture is offset by the environment.

a situation in which both graphics and high cognitive load exist resembles a situation when neither is present.


4.1 The concept of Participant If we closely analyse the ODOL ontology, we can easily .nd out a few minor incoherences in the de.nition of some of its concept.

the ontology introduces the central concept of Participant, which is de.ned as the father OWL class for all of the pattern s elements templates, like ClassTemplate, MemberTemplate, RelationShipTemplate and so on.


INTRODUCTION Term rewriting systems [4, 5, 10, 16] are versatile models of computation in their own right and underlie several modern declarative programming languages, e.g., ASF+SDF [19], Elan [6] and Maude [8] to name a few.

programs in the functional logic programming languages Curry [12] and Toy [17] are generally regarded as TRSs and are executed by narrowing.


host machine and thus imposes some overhead to save and restore state on function entry and exit.

regions are limited tohaveasingleentrybutarenot constrained otherwise.regions are allowed to contain loops, non-linear control .ow and several exits.


Distributed aggregation is a common name for a set of functions that provide a summary of some global system property.

they allow local access to global information in order to simplify the task of controlling, monitoring and optimizing distributed applications.


The basic idea is to introduce an extra condition that assumes that the expected number of failures (denoted by µi) at each speci.c level during the execution is related only to the execution scale (i.e., the number of processes/cores).

we can denote µi to be µi(N), regardless of the application length.


The Want array is used by processes to announce their wish to enter the CS.

the value stored in entry Want[p][q] is a ticket value , and it indicates to process q whether p is trying to enter the CS.


As a result, maintainability or reusability may decrease, which increases the e.ort for further SPL development.

we focus on changes regarding variability modeling and implementation within DOP and do not consider other parts of the SPL engineering process [19].


While these techniques are very good in achieving their intended goal, namely, protecting against attacks launched by some outsider, and doing so with very low overheads, they are not useful for general-purpose memory error checking.

these techniques do not detect access errors at all, but simply prevent such errors from being used to launch attacks.


One of the pending works is to unify all the tools under the same platform.

we are designing a tool for the definition and configuration of a feature model using the facilities of the Microsoft Domain Specific Language (DSL) tools, integrated in Visual Studio and connected with the goal analysis tool described in [15], also based in Microsoft products.


We show that the extension is signi.cant both theoretically and practically.

we investigate the following instances of WPO characterized by how weights are computed: WPO(Sum) which uses summations for weight computation.


Through automated decisions at run-time, developers will be freed from the need to predict, formulate, and maintain adaptation rules, so that the effort involved in developing context-aware applications will be greatly reduced.

this paper focuses on the mechanisms used in CAMPUS to dynamically derive adaptation decisions.


Using our analysis, we design optimized algorithms for scatter and gather.

we design multi-pass algorithms to improve the locality in the memory access and thereby improve the memory performance of these operations.


g = slowRetrieve of a SAL program p, that returns the value stored in a slow access memory.

given as parameter the integer Address i, the procedure g returns the value mem[i], where mem is a global array variable, if i is within the accessible range.


3.2 Translation goals and limitations (1) We only translate a discrete-time, non-ambiguous part of Simulink.

we do not translate blocks of the continuous-time library, S-functions, or Matlab functions.


Although various model transformation approaches have been developed [2], the role of model transformation in evolving models has not been explored fully.

this research poster describes the benefits that model transformation offers in terms of dealing with the difficulties of model scalability.


They can, first, programmatically locate values to change using XPath to probe the generated XTBL+, which is generated at the first step, and then Mulini can change all corresponding points within intermediate specifications, which are generated over the initial code generation process, using XML mapping technique.

the target portions are linked between intermediate specifications during the initial processing by mapping XML elements of a specification to those of next specification.


On the other hand, if the veri.er does not consume p but rather some other, adversarially chosen stream pA that does not contain p as a pre.x (e.g., because the server is behaving maliciously or incorrectly), then the only way the veri.er can accept an incorrect result is if the adversary has found a hash collision.

the consumed stream pA contains an element s  that corresponds to an element s in p such that s but hash s = hash s = s .


For the examples that are inconsistent under our model, it was always possible to produce a concrete input that forces the program to violate basic invariants under .oating-point semantics.

these examples would be inconsistent under any other reasonable de.nition of consistency.


Max Black stresses that the secondary subject is to be regarded as a system rather than an individual thing (p27).

the term engineering is not used in isolation; but evokes a whole range of concepts and terms involved in the engineering frame of reference.


On the other hand, to decide whether a given FSM has an adaptive distinguishing sequence can be achieved in O(pn log n) [3].

deciding whether a checking sequence generation method can be used on a given FSM is at least PSPACEcomplete when the method is based on preset distinguishing sequences, while it can take polynomial time1 when the same method is adapted to use adaptive distinguishing sequences (this does not speak about the complexity of the method itself).


We say that .1 is subsumed by .2 in G, written G |= .1 .2, if for all valuations V consistent with G, V(.1) V(.2).

in all possible instantiations of the type variables in G, quali.er .1 being A implies that .2 is A. Kinding and variance.


1 pipeline{ 2 for(int i=0; i<100; ++i) { 3 int x = foo(); 4 if(i% 2!= 0){ 5 fifo_put(&f,x); 6 fifo_get(&f,&x); 7 bar(x); 8 } 9 } 10 } The dependency analysis stage forms a large number of candidate threads by computing a backward data and control slice [16] from each unprivatized operation ignoring data dependencies on channel operations but including all other operations in the slice.

we repeatedly apply rules (1 3) to form candidate threads.


There were also 4 harmless errors that would not have caused any performance problems.

the participants speci.ed extra .delities that Chroma would ignore.


Such a translation scheme is an implementation detail that HLL programs must never rely on.

these details should not leak through the reflective API.


We classify users according to their upload link bandwidths.

let M denote the number of user types, where a type m user has upload link bandwidth wm.


Incase anoverrun occurs, the system will be signalled by this blocking timer that was set.

the signal is sent when the blocking time measurement is reached.


In fact, epidemic routing is a reasonable approach where no information can be determined about the movement patterns of nodes in the system.

where there is no basis on which to distinguish the movement pattern of any node from another, and the movement pattern of each node is individually random, the only choices about message placement are to place messages randomly or to place them everywhere, since there is no more intelligent basis for making a decision.


Scheduling Policies We would like to experiment different scheduling policies.

we could use lookahead now offered by the more declarative model to execute in priority tasks that reduce the memory pressure or whose results are required by many other tasks.


in M in the case when t0, t1 are 2A-involutions in M (recall that all M-representations of dihedral groups can be realized as subalgebras of the Griess algebra).

the number in the type is the order of ..


As sorting dimensions in order of importance, we can extract important information which is called Principal Components (PC) and can discard low signi.cance dimensions with minimal e.ort.

we perform the technique to pick the most powerful one among factors(parameters) describing a task.


The Variety Engineering Method and the underlying modeling language will be enhanced according to the Design Science Research Framework.

we need to develop concepts for the simulation of communication tasks within a given IC structure which takes the measured varieties as inputs and assesses the quality of the IC structure as output.


During the update the JIT compiler will also need to flag any superclass in the system in which running subclasses may be updated in future execution.

for any loaded class contained in the original component the JIT compiler will flag the necessary super-class de-optimizations needed to introduce the checks to determine if the executing instance ( this reference) is updated or not.


We introduce the necessary notions below: Genetic fragment The genetic fragment (or just fragment) represents the concrete subtree that gets changed by a genetic operator in the course of producing the o.spring.

the subtree that gets swapped from the nonroot parent to the root parent by crossover, or the node or subtree that gets modi.ed by mutation.


While independent list elements are generated simultaneously and all elements inherit the same attribute list from their parent (in other words, every list element is generated over the same attribute list and cannot affect each other), in dependent list generation, elements are generated one after the other and each one inherits the attributes from the previous one.

the generated attributes .ow through the list and the currently generated elements can affect the following siblings.


Collaboration Patterns in the SOA Ecosystem Michael Poulin, Ph.D. Head of Business & Technical Architecture, BuTechCon Ltd. 264 High St., Beckenham Kent, BR3 1DZ, UK +44(0) 797-076-2133 m_z_poulin@hotmail.com ABSTRACT In this paper, we argue that orchestration and choreography are not two independent patterns, but they go together addressing two parts of the same thing known as a service composition.

when a service-conductor engages another service in the orchestration, actual interactions with this service may be scripted using choreography.


fundsCybFacil and hostCybFacil are facilitator actors of FundsCyberOrg and hostCyberOrg respectively Most interestingly, if the resources available through the contract with the current host cyberorg are not suf.cient, a regional cyberorg may negotiate a better contract with another cyberorg.

although the cyberorgs for sub-regions are created by cyberorgs for larger regions, the sub-regional cyberorgs are free to migrate elsewhere in search of a better matching execution environment.


It is intended to cover practical issues relating to how we might integrate Studio Based Learning techniques into traditional curricula as an agent of more significant potential changes.

participants will be asked to consider how much of the play could be used in their class, or is being used already.


The detector-emulation algorithms (Figures 5 and 7) are anonymous but the anti-O extraction (Figure 6) is not.

the notion of relative implementability of failure detectors (not tasks), here and in [20], is not anonymous.


Once the parallel program is decomposed into phases, the rest of our approach operates on one phase at a time.

the rest of our approach goes over the phases, and each phase is op timized using the techniques explained below.


no calls to the library functions) and do no allocations when the fast .onum extension is turned on.

its result is basically as good as our method gets, and can serve a reference point.


The semantics of .wit has strictly more freedom in evaluation order than both call-by-value and call-by-need.

callby-need evaluation can be obtained by using the same reduction rules but restricting the evaluation contexts to the following E := D .{.


An occurrence of the super option, for example, consists of two adjacent terms: the keyword #:super followed by an expression, e.g., (de.ne-struct point (xy) #:super geometry #:mutable) No single-term pattern describes the inspector option.

the pattern (#:super sup:expr) does not, because #:super and its argument do not appear as a separate parenthesized term, such as (#:super geometry).


AVA: Automated Interpretation of Dynamically Detected Anomalies Anton Babenko Leonardo Mariani Fabrizio Pastore University of Milano Bicocca University of Milano Bicocca University of Milano Bicocca viale Sarca, 336 viale Sarca, 336 viale Sarca, 336 20126 -Milano, Italy 20126 -Milano, Italy 20126 -Milano, Italy a.babenko@campus.unimib.it mariani@disco.unimib.it pastore@disco.unimib.it ABSTRACT Dynamic analysis techniques have been extensively adopted to discover causes of observed failures.

anomaly detection techniques can infer behavioral models from observed legal executions and compare failing executions with the inferred models to automatically identify the likely anomalous events that caused observed failures.


Formulae (A6) (A9) state that each running session is associated with exactly one user.

the predicate user represents a function from sessions to users that is constant over a session s lifetime: 0 .s.


This also allowed us to explore aspects of game design practices in regard to handheld AR design and education.

we were able to leverage the prototyping process familiar to game designers and the natural emphasis it places on learning by doing, to gain some insight into how to effectively use this process to explore mobile AR interaction techniques, and apply it more broadly as an educational tool.


The designer (as a user of ArchE) provides: (i) the meaning of scenarios and responsibilities, (ii) the mapping of scenarios to responsibilities; and essentially, (iii) the design context.

the designer can trust the quality-attribute reasoning followed by ArchE when proposing tactics, but she does not have to agree on applying the best tactics found for satisfying her scenarios.


Consider the matrix multiplication kernel as an example, each entry in DeviceQueue() function.

if the total number of tasks that have been assigned to devices is large enough, then the scheduler will stop dispatching tasks in the ready queue to devices.


0 Vice versa, if an obligation has been terminated, intuitively it must be the case that the obligation has been ful.lled.

unless an obligation has been achieved (or is terminated after its deadline in line with Constraint 5), it should persist.


5.3 Experiences It is natural to ask whether or not the observed signi.cant statespace reduction translates into any tangible bene.ts for improving system reliability.

we look at two aspects: (i) DEME-TER s ability to explore completely a meaningful logically bounded state space of a system implementation for a higher degree of reliability assurance and (ii) how DEMETER improves our ability to .nd bugs.


It should be noted that our implementation of activate and deactivate instructions turns on/off several cache lines which the object (or array element) in question is mapped to.

our scheme works on a cache line granularity (though, with a slightly more complex circuitry, it can be made to work on a word granularity).


CONCLUSION In this paper, we have presented our vision on addressing the problem of planning deployment adaptation in ad-hoc clouds.

we have described a generic architecture for deployment adaptation logic that is based on the concept of emergent component ensembles.


Let .i (with 0 <i <diam(g)) be a con.guration such that a vertex v belongs to a non-zero-island I of depth k = 0in .i.

assume that v does not belongs to any island in .i-1.we have rv i-1 .


In an existing network, HBAgents are interconnected by a heartbeat connection, as shown earlier in Figure 1.

they ping each other at regular time intervals in order to signify their presence.


Analysis for CRT Key Pre Distribution Key connectivity is a measure of the probability of key-sharing 0.73 0.72 between two or more nodes.

it is a measure of the number Connectivity 0.71 0.7 0.69 0.68 0.67 0.66 0.65 of pairs of nodes that have at least one key common between them out of the total number of possible pairs of nodes.


However, after the transposition, the relation hi .. o holds.

we can not only transform o with any ci but also compare any hi with o in place!


The social network in this paper always includes all users/nodes that have been created and not yet deleted.

many of the nodes in the graph can be of.ine at any given time.


Since TOP cares about code functionality more than code readability, we use a straightforward but effective inlined assembly rewriting approach to generate the corresponding C code.

we traverse the BBHT (§3.1), starting from a user-speci.ed address or a default address.


In this example, the triangle of clients C1, C5, and H1 violates the triangle inequality.

the length of the side (C1, H1) is longer than the sum of the other two sides(C1,C5) and(C5, H1).


Theoretical y, Phase 3 of our algorithm is optional.

without this phase, it is stil possible to generate the finaltest sequence.


For a job of tittwith a deadline d, its deadline is virtually transformed to d- min{Cti }.

i,Ctt For a job of {tj | i<j<k} and tktwith a deadline d, its deadline is remained d. tittis deemed to have a relative deadline Ti - min{Cti }.Once a job of ttthas the earliest deadline i,Ctt i on Px, no other jobs have earlier deadlines until the job of tittcompletes, since the period (relative deadline) of tittis guaranteed to be the smallest in .x by the characteristic of the task assigning algorithm presented in the previous section.


We avoid this bottleneck by reusing epoll registrations and thereby avoiding taking epmutex on every operation.

when we register an event, we .rst attempt to modify an existing registered event.