These regional results raise the interesting possibility that botnets can migrate in response to takedowns.

by reducing the number of infected hosts in one region, a takedown creates incentives for botnets to find new vulnerable hosts, thus moving the problem elsewhere.


In most common cases, an indirect jump is used to dispatch execution from a jump table, and all legitimate targets of this jump are the corresponding case branches, which can be identified by the previously discovered constants.

in this part, we constrain the rest of the indirect transfers in the binary, which correspond to the border nodes of continents.


This could be due to the fact that it introduced a new password policy of minimum password length of 8 while the website was live [10].

only a small amount of early users have passwords of length less than 8; (ii) the majority of passwords of most datasets are Uni and Bi.


From Table 2, we observe that (i) the majority of passwords of all datasets have length less than 12.

a significant number of passwords of most datasets have length less than 8.


Further, the sites that have many high-value accounts, e.g., Computers/Shopping/Business sites, tend to require users to choose longer passwords.

37 sites have explicit maximum password length constraints.


This implies CSDN is more vulnerable given Tianya than given Rockyou.

according to the results of the two meters, LinkedIn is more vulnerable given Rockyou than given Tianya.


From Fig.2 (a) and (e), we see that most cracked passwords of CSDN are labeled as weak.

there are still a considerable number of cracked passwords of CSDN that are labeled as strong.


How is passwords' strength accurately measured?

it is important to consider which algorithms should be combined in designing HPC schemes.


The number of false positives is cut by almost a factor of 5, while the proportion of lost true positives is not much more than 1/4.

dDA allows us to retain most of the benefit of being able to find OBJECT OVERRUNS, while at the same time dramatically reducing the number of false positives.


In addition, the DIVINE implementation would not actually create a larger object in CodeSonar/x86's IR in the presence of an overrun the ASI results would not be incorporated in that way.

there are some important differences between the two tools.


Insofar as the initial set of boundaries provides an overapproximation to the ground truth, our goal is to eliminate as many spurious object boundaries as we can; at the same time, we want to retain the true boundaries that enable the detection of actual buffer overruns.

it also has an effect (sometimes sizable) on the analysis recall.


Our parameter-offset analysis was inspired by the Howard tool [24, 25].


It provides an easy means for consumers to store and share their data, also in mobility through convenient apps.

such valuable functionality raises several security concerns.


Tavizi et al., present an architecture for the adoption of UCON in the Cloud environment, mostly focused on the obligations enforcement.

this architecture is presented at a very high level and to the best of our knowledge it does not describe in details the additional components required for the enforcement of UCON policies, in particular for what concerns continuous policy enforcement.


Typical issues for such cloud services are related to data con.dentiality and ownership, uncontrolled data replication, physical storage location and so on.

through the Cloud enforcement engine, resources become available for Data Consumers through the Mobile enforcement engine.


In this approach for intrusion detection, the system calls serve as the source for mining and predicting any chance of intrusion.

when compared to the artificial neural networks approach, the detection accuracy is lesser [11].


Similarly, we may choose to use the DARPA 1998 or 1999 standard dataset.

the research should first start with the studying benchmark datasets.


A Mann-Whitney U test shows that the participants' experience significantly differs based on their gender (U=262, n=42, p=0.046, r=40.4).

male participants indicated to be globally more experienced than female participants.


If the parent process is still running when the monitoring agent captures its snapshot, all further information about the parent is readily available.

no matter the event type, this root node needs to be semantically significant.


As indicated, the margin and PNMod parameters are also beneficial because they expand the CRP space.

two copies of the logic expressions for GF(4) given in [23], and two copies implementing their inverse, synthesized to a set of 16 4-input LUTs labeled L15 down to L0.


The underlying entropy source consists of both individual LUT gate delays and the interconnect routing delays, which are combined in unique ways and measured as path delays by HELP.

the number of paths reflects the amount of entropy present in the functional unit.


Table 2 presents some additional information about the fragments and surprisals in our corpus, where n=1,2,3.

we observed 641 unique 1-grams in our corpus.


We noticed that compiling this code at a low level of optimization (gcc -O1) improves the stealthiness of this code by avoiding the setnl opcode.

the level-1 optimizations of GCC also simplify the boolean expression in the guard of the if statement, so they decrease the strength of this obfuscation.


However, the problem of the password-based authentication scheme is that a server must maintain a password table to verify the legitimacy of a login user.

the server requires additional memory space for storing the password table.


A selects any identity IDany, and generates a random number n1.

this is impossible because the secret key x does not exist in the smart card.


To overcome this drawback, new authentication schemes using biometrics and smart cards have been proposed [9, 10].

these proposed schemes are based only on a single-server environment, and are limited due to the number of network services required.


If the two conditions are not being satisfied, nobody can reconstruct the data secret by other methods.

even if a provider has more than k shares, without other providers cooperation, he cannot perform secret reconstruction.


In addition, in the real use-case, one may expect that that m < l, < n .

hence in this paper, we will consider the situation where m < n.


However, from the viewpoint of information security, certain risks must be mitigated such as unauthorized access, data leakage, data falsification and others.

information management has become an important topic in the last few years.


To update shares, shareholders (different groups servers) have to assemble enough shares (i.e., the number of shares must over threshold) to reconstruct data secret s or reconstruct authority secret v and redistribute new shares again.

if we do that, it will have a risk of leak data secret s or authority secret v in the process of reconstruction.


The goal of PLC1 is to ensure that there is enough water in T101 to be supplied to stage 3 for ultrafiltration.

the control algorithm in PLC1 monitors water level in T101 at predetermined intervals.


Note that the states of MV101 and FIT10 are locally consistent.

any anomaly in stage 1 has a very high likelihood of being reflected in stage 3; stage 2 does only has chemical sensors and hence requires chemistry-based detection method not used in the experiments reported here.


A number of experiments conducted reveal that the distributed detection based on invariants is effective in detecting SSMP attacks.

replay attacks on the first stage of a CPS, that has no previous stage, need additional state information for detection.


Further, it is assumed that an attacker has access to any one stage of the CPS.

the attacker could compromise one or more entities in any one stage to which access is available.


According to [13], interesting points are time samples providing the most information for side channel attacks(i.e. Template Attack).

for each guessing key keyi, the attacker calculates a column of assumed power consumption Pkeyi (i.e. Hamming weight), then a correlation coefficient ρ in equation (9) will be calculated.


For the same-core channel, Smartphone has a wider dynamic range of 10 .C, while the dynamic range on Laptop is just 7 .C.

for the 1-hop channels the dynamic range is wider on Laptop, where it is at least 6 .C for both core 1 and core 3, compared to the dynamic ranges of just 4 .C and 2 .C, respectively, measured on Smartphone.


In order to verify the motion of an object, multiple successive measurements are required to estimate the velocity and heading of the target.

these approaches can only verify the average velocity and heading between the considered messages.


The en-route airspace is of special interest to us since most aircraft are usually at high altitudes.

the dataset from the OpenSky Network contained almost twice as many positions from the en-route airspace than from the lower airspace.


The goal of this section is to find a method to determine the FDOA accurately enough for secure verification real flights.

it can arbitrarily adjust its transmission frequency and we do not impose any restrictions on the attacker's knowledge.


Secondly, the center frequencies of the transponders differ significantly as indicated by the horizontal difference of the ECDFs in Figure 5a.

we must assume that the actual transmission frequency is different from 1090 MHz as the transponders are obviously not calibrated or synchronized (e.g.


Our experimental results with air traffic control signals demonstrate that our approach can be used to significantly enhance the security of air traffic management systems.

we provide means for measuring the Doppler shift of air traffic signals using off-the-shelf software-defined radios.


Each setup recorded all ADS-B messages along with their raw I/Q samples using a modi.ed version of the GNU Radio-based software receiver for transponder signals gr-air-modes2.

directly measuring the FDOA with the above method turns out to be much more robust in the presence of the highly unstable transponder signals.


Due to the low sampling rate (up to 200Hz) on most mobile devices, it's difficult to capture the details of the running CPU instructions.

we show that, by extracting both time and frequency domain features from EMRs, MagAttack can still learn the footprint with a low sampling rate and can infer which App the victim is interacting with.


The reverse channel coding aims to reduce the discrepancies between the encoded bits by the wearable and the device.

the original encoded bit sequences are considered as messages with a limited number of errors, and are converted into shorter sequences using a error correction code (FEC) decoder.


The shapebased encoding faces a similar issue, as the two curves do not coincide in non-resonant frequency ranges.

we turn to the third option that encodes the resonant and antiresonant frequencies to ensure the matching rate.


Note that we can only accurately obtain the resonance properties when the system is in the steady state.

it is hard to identify which part of the accelerometer data is collected in the steady state, as the duration and patterns of the transient state depend on many confounding factors.


Wrist circumference and BMI are import physical attributes related to hand vibrations, as our system should be robust for users of different physical attributes.

the wrist circumferences range from 5.51 inches to 7.48 inches, and BMI ranges from 17.5 to 27.70.


To avoid repetitive extrema, we select at most one maximum and minimum in each sliding window of 10 Hz.

if there are multiple minima or maxima in one sliding window, we select a winner based on amplitude and discard the others.


In practice, the analog sinusoidal waveform is approximately generated with binary voltage levels using Pulse Width Modulation (PMW).

pMW modulates the duty cycles of the DC power to simulate a voltage between the DC power voltage and zero voltage.


Like the design of bene.cial smart contracts, CSC construction requires a careful combination of cryptography with commission-fair design [34].

a party can generate arbitrarily many public keys.


At its core, VUDEC is designed and the overall system architecture along with its centrally and decentrally operated components are specified.

the standardization of vulnerability descriptions allows system operators to make use of information and knowledge (e. g., specific measures for vulnerability mitigation), which has been acquired by other network users earlier on.


To clients, reverse proxies act as the service's endpoints for example, if a domain name is used to advertise the service, the domain will resolve to the reverse proxy's IP address.

a reverse proxy looks like the origin server and requires the collaboration of the service owner to be installed.


To avoid detection, attackers may attempt to remove discrepancies introduced by the reverse proxy.

complete removal requires deep understanding of the reverse proxy code and configurable options, as well as careful configuration of the origin servers.


Furthermore, they do not provide the CoKey key combination mechanism.

the physical presence of the crypto token is not sufficient to decrypt data encrypted with it.


Threshold schemes form a good protection mechanism against differential power analysis (DPA).

using it allows building cryptographic hardware that is guaranteed to be unattackable with first-order DPA, assuming certain leakage models of the cryptographic hardware at hand and for a plausible definition of “first order”.


For drivers who pay the full price the tracker can of course be turned off.

for drivers who took the discounted contract, tracking the truck position in an unrestricted way poses clear privacy problems.


Such smart industrial control systemsfall into the category of Internet of Things (IoT).

in many cases, the data transmitted by such IoT devices includes sensitive information and users are faced with an allor-nothing choice: either they adopt the proposed services and release their private data, or refrain from using services which could be bene.cial but pose significant privacy risks.


Without overlaps, patterns of maximum length are uncovered in 100% of the cases when thermal attacks are performed within 30 seconds after authentication (Figure 7).

depending on the authentication scheme, the use of thermal cameras can still help the attacker to reveal the part of the input made on the touch screen.


Our implementation is open source, hence allowing further experimentation with thermal attacks.

pINs and patterns remain among the most popular authentication mechanisms as of today [23, 49].


In that work, the authors address the problem of differentially private parameter tuning in machine learning applications.

a machine learning model (e.g., a classifier) is trained on a dataset T and its performance is validated on a hold-out dataset V.


Decision tree construction methods differ in the implementation of NI.

we next describe four alternate implementations of NI that result in four splitting criteria best algorithm, group regret, minimum average regret and regret variance criterion


There are general-purpose algorithms (e.g. the Laplace Mechanism [6] and the Exponential Mechanism [18]), which can be adapted to a wide range of settings to achieve differential privacy.

the naive application of these mechanisms nearly always results in sub-optimal error rates.


A part of homomorphic encryption has been successfully applied in some domains, such as database queries [58] and MapReduce programs [59].

its significant drawback is high performance overhead and incompatibly with existing applications [60].


NoHype [49, 50] and TrustOSV [51] try to build an isolated execution on multi-tenant clouds by providing fixed cores, pre-allocated memory to a VM.

there is less interaction between the hypervisor and VMs at runtime, but the resource utilization is low.


We also try to use the HA-VMSI interfaces to send a malicious request for overwriting the page tables.

it is prohibited by checking whether the values violate the security policies of HA-VMSI.


VA in a guest VM is translated to IPA through the Stage-1 page tables managed by guest OS just like non-virtualized systems.

having a trustworthy security monitor provides a secure foundation for the cloud server to strengthen the security of guest OS and its applications.


While the security monitor is only in charge of VM s integrity and privacy protection, such as validating each mapping on Stage-2 page table, tracking the usage of physical pages, and deploying the pointer of Stage-2 page tables.

instead, HA-VMSI still maintain the flexibility of the hypervisor, but the security protection is decoupled from the hypervisor into HA-VMSI.


In the meantime, these mapped pages will be unmapped from the page table of the hypervisor.

protecting VM data on the cloud is still far from trivial.


And each core has an independent TLB and each TLB entry contains a VMID tag corresponding to the address.

hA-VMSI can run simultaneously and yet securely on different cores alongside the virtualized system.


We use 4 VM types with memory sizes from 512MB to 4GB, to evaluate the performance impact of HA-VMSI prototype for a VM creation.

section 5 presents our prototype implementation.


When the switch agent finishes its startup, HA-VMSI enables the trap events and deprives the hypervisor from executing some privileged instructions that allow the hypervisor to control critical system state, such as defining the location of its page tables and exception handlers.

the VM exit cannot be bypassed from HA-VMSI.


Compared to these systems, HA-VMSI provides protection at the whole VM level, which naturally fits for the context of multi-tenant cloud.

when creating a mapping, some new page tables may be required.


Results demonstrate that their CNN outperform traditional feature-based methods in detecting JPEG steganography provided that the number of training data is huge.

not surprisingly, adding more layers causing trouble in training; this can be observed in Fig.  4 showing abnormally higher training errors achieved by a more complex 20-layer CNN, and there is no question that the validation performance also suffer.


Researchers observed as children moved through the process.

they remembered what kinds of usernames and passwords they created, what picture they chose, and generally where the points were located on the image.


It would take human analysts many months to complete a single round of tests, and even then they are bound to make numerous mistakes in the course of testing

one needs an automated framework to run the tests.


EtherNet/IP is an object oriented industrial protocol.

it is an implementation of the common industrial protocol (CIP) [22]on top of the TCP/IP protocol stack.


In order to take advantage of these features, our current implementation assumes that a house contains sensors and Wi-Fi controllable lights.

such products are already commercially available, and should become more commonplace with time.


The type system definition pays particular attention to the mode of the typing judgment, in the sense of logic programming (Debray and Warren 1988).

the type context and term are interpreted as inputs to the typing judgment, while the term's type is viewed as an output


Our results establish that our system ensures that well-typed programs do not leak confidential information under the security policy prescribed by the assumed security lattice.

data does not flow from a security compartment to another if they are unrelated or if it is a down-flow in the security lattice.


Duplicate keys are not allowed in our model.

if the key has changed, then the seek function restarts from the root of the tree.


If the delete operation is complex, then it advances to the discovery mode after which it will advance to the cleanup mode.

if it is simple, then it directly advances to the cleanup mode (and skips the discovery mode).


It then sets the delete-flag on the left edge of the target node using a CAS instruction.

we now describe the results of the comparative evaluation of different implementations of a concurrent BST using simulated workloads.


Since language specifications often leave some decisions to compilers for flexiblity, a compiler is allowed to remove behaviors.


However, for stencil or sampling operations as consumer functions, the redundant computation introduced by inlining can be quite significant.

we restrict our inlining to cases where the consumer functions are point-wise functions, and rely on our schedule transformations to enhance locality for the other operations.


Halide [36, 37] a recent domain-specific language and compiler for image processing pipelines focuses on both productivity and performance.

the Halide compiler requires a schedule specification to generate an implementation.


This process is complicated by the fact that while a system call instruction is only one byte long, a jump instruction requires five bytes.

in order to rewrite the system call with a jump, we also need to relocate some of the instructions surrounding the system call i.e. perform binary detouring via trampolines [22].


While Sections 4.1 and 4.2 illustrate the worst-case synthetic and real-world scenarios for a system call monitor, in order to compare VA R A N directly with prior NVX systems, we have also run it on the same set of benchmarks used to evaluate prior systems.

we chose to compare against three state-of-the-art NVX systems: Mx [21], Orchestra [40], and Tachyon [33].


We adopt this scheduled communication [10] strategy for communication slack.

the next two classic energy saving approaches are intended in particular for slack arising from non-communication, i.e., mostly, computation.


Given a set of past tickets in buckets with their resolution times, TAACT categorizes incoming new tickets in each bucket into bins within the buckets, using only the textual description field of the tickets.

based on the minimal information available for all tickets, TAACT predicts whether an incoming ticket is likely to require low, moderate, high, or very high time for resolution.


Using these indicators, measures such as precision, accuracy and recall are calculated.

they consider distinct lexims in the churned source code, which are quite huge in number, as features and extract them from churned source code by bag-of-words approach (BOW) [28].


[12] focuses on the reuse aspect of inheritance and proposes a new metric that is theoretically well grounded.

in section 5 we explain how the metric is computed and in section 6 the way the metric is visually represented for an entire system.


A task can have more or less partitions and spaces than that may be available in its target execution platform.

a task operates on logical spaces and partitions, and we call them Logical Processing Spaces (LPS) and Logical Processing Units (LPU) respectively.


Advancements in more accessible CAD tools that allow novice designers to simply drag and drop forms into a 3D model [7], or use evolutionary modeling [19], computer vision [2] and machine learning [9] to create frameworks that map descriptive words onto a modular set of existing 3D designs have made this process slightly easier.

many thanks to the MIT Media Lab consortium for supporting this research.


However, such sharing is ineffective when a single application fully utilizes the available memory by itself.

we expect GPU memory to be shared mainly among applications using relatively small amounts of GPU memory.


We consider this delay acceptable since most GPU applications tend to re-use previously allocated memory instead of allocating and freeing buffers frequently.

the delay did not always mirror the time needed for a DMA transfer of the same size.


The memory management of current GPUs lacks some features found commonly in CPUs: Current GPUs typically treat page faults as fatal errors, and their page tables do not contain reference-or dirty-bits.

well-known memory management techniques like demand paging or traditional page replacement algorithms cannot be applied to GPUs.


In the Monte Carlo method, true variance δ2 is usually unknown.

it can be estimated from the sample values.


The hypervisor can dynamically adjust the allocated memory pages of a VM by memory swapping without any permission from guest OSes.

such a benchmarkbased approach cannot account fine-grained resource allocation changes accurately.


Most of the recent studies for hypervisor security have been focused on providing confidentiality and integrity of user data.

a neglected aspect of security is the availability of resources.


If either of the transmissions in Slot 1 or 2 succeeds, following transmissions from Relay 1 to A1 will be scheduled in Slot 3 and Slot 4.

as an integral part of WCPS 2.0, we have implemented a WirelessHART protocol stack in the TOSSIM simulator.


Also, to efficiently correct emergencies, the valve, which is normally OFF , is sometimes switched to ON .

the control strategy for this system is hybrid, since whenever an emergency is activated the controller behavior is changed.


This abstract model is then used to automate the generation of test cases in a systematic way.

the generated test suite is typically guaranteed to meet some coverage criteria, thus providing additional assurance about the quality of tests.


Finally, the algorithm is guaranteed to find a unifying counterexample for every ambiguous grammar, but the search will not terminate when infinite expansions are possible on unambiguous grammars.

this semi-decision procedure for determining ambiguity is sound and complete.


The authors report average speedups of 3.8x— on 6-9 hardware threads.

the paper's evaluation is problematic in two respects, making it diffcult to interpret the results: (1) the sequential analysis they compare against used an arbitrary node ordering for the worklist, which in our experience can cause slow-downs from 2 5Ã— relative to a more optimized node ordering strategy; and (2) their evaluation reports analysis runtimes rather than speedups.


The search would be reasonably efficient if DynamoRIO were to keep a sorted data structure of spans, but it does not because that large and expensive structure would be of no value for module image VM areas, which comprise the vast majority of translated code.

this project was partly supported by the National Science Foundation under grants CCF-0846195, CCF1217854, CNS-1228995, and CCF-1319786.


On Python, the indirect jumps are most often very well predicted for most benchmarks, even by the 6 KB ITTAGE.

in several cases the prediction of indirect jump is poor (see for example the Python chaos, django-v2, formatted-log, go).


A latency to access data within the ring varies and can be as high as accessing data from the memory.

since stencils are at the heart of many scientific computation and are very compute intensive, there has been a considerable body of research on how to improve the performance of these codes [12, 15].


All existing works handle work-groups by scheduling them in distinct CPU threads.

cPU threads do not need to syn-chronize until kernel completion, which is convenient because synchronization across threads on a CPU is expensive.


PCFS uses a formal logic with more connectives than the Guardat policy language.

for each access pattern in each configuration, we perform five experimental runs; each run has 20,000 accesses (a total of 100,000 accesses for each configuration).


However, Popcorn is always faster than its competitors.

popcorn is up to 3.5 times faster on 57 cores on Class C.


This widget relayed CMAPI messages between OWF based map widgets and the uMap server.

when users using the uMap browser client would manipulate geospatial information on their maps, the OWF users could see the same information and vice versa.


Software-managed hybrid memory is a promising way to incorporate NVM in main memory due to its architectural simplicity.

there are significant performance issues caused by interference in the memory system due to data migration between DRAM and NVM and a lack of effective migration policies.


For example, in healthcare, the Cochrane Collaboration provides a webpage on Other Software Resources1 , which presents a list of available tools.

the list is short and is missing many, potentially, helpful tools.


The potential for time-saving was also praised.

speeding up quality assessment by including a previously assessed study (from a past SR) might mean that “you wouldn’t have to quality assess it again.”


The majority of tools identified by participants were reference managers.

refWorks and EndNote were mentioned most often.


Many participants felt support for multiple users (F4-F01) within a tool was really important.

allowing users to collaborate within large-scale teams was considered very useful.


As the size of J10 is odd we know that it is not empty.

all the vectors in J10 must satisfy that they have 1 in the first coordinate and 0 in the remaining coordinates.


Finally, we believe that a better understanding of the relation between Reed-Muller codes and Polar codes is needed, and perhaps more generally an understanding of which subspaces of polynomials generated by subsets of monomials give rise to good, efficient codes.

it would also be interesting to investigate the scaling of the blocklengh in terms of the gap to capacity for RM codes.


Curiously, the two seminal papers from the late 1940s giving birth to coding theory, by Shannon [39] and Hamming [22] differ in whether one should consider recovery for most corruptions, of from all corruptions.


Consider the pattern (1, 0) in the first two rows of U .

consider all columns of U that have 1 in their first coordinate and 0 in the second.


The advantage of global recovery is that it can be done in a semi-transparent way: the application does not necessarily have to be aware of the failure.

due to the intrinsic global nature of the recovery algorithms, global recovery present scalability challenges.


However, these works were often theoretical or used a (simplified) model together with a simulator, while realistic implementations in actual resource managers were not available for various reasons.

those promising results were rarely reflected in the practice.


In summary, we can apply the tile size parameterization process to any set of tiling hyperplanes (diamond or otherwise).

other stencils that require different diamond tiling hyperplanes can also benefit from this process.


Figure 10 shows the software components which contain a large number of functions.

developing long-term stable product line architectures.


A semi-formal or formal evaluation with supporting tools is necessary to speed up the development process.

metrics are not meant to replace the scenario-based methods like ATAM [4] but to augment the analysis of architecture based on data and measurement experience.


Continued performance gains must be achieved within the context of reusing existing scientific software that represents countless hours of investment on part of expert programmers.

as the cycle of porting codes to realize the potential performance offered by the arrival of the next generation, or even the next technology of hardware continues (i.e. “performance portability”), software development productivity must be maintained by forward looking elimination of software bugs and defects.


We were specifically interested in middleware and software frameworks.

software that is very general in its purpose because of its role as part of distributed cyberinfrastructure.


Whether or not a software product was available under an opensource license per se was far less a concern for most respondents than were its capabilities, cost, and reliability.

three of the top five most important selection criteria identified relate to characteristics of open source software total cost of ownership, long-term availability, and initial purchase cost.


Figure 5 and Table 4 shows that NMCS uses, on average, 25MB less memory than best-first search, but 40MB more memory than beam search, for the SUTs considered in these experiments.

these differences have little practical impact given that JPF in this environment always used at least 123MB.


JPF is, in essence, a Java virtual machine (itself written in Java) and this enables JPF to control and measure many aspects of software's execution.

it can enumerate and control the choices made at non-deterministic points in the program, such as the generation of pseudo-random numbers and most importantly for the experiments here the interleaving of separate threads in concurrent program.


there is a much smaller effect of the simulation depth on space efficiency.


Since the execution time improvements of our proposed techniques are quite significant the overall CPU energy dissipation will be reduced.

the energy usage improvements presented in this paper are for the L1 DC and the DTLB only.


A typical CPU performs all data accesses in a general fashion.

the context of a data access can affect how the L1 DC can be most efficiently accessed.


This approach requires an associative check of block numbers and word offsets of all the entries in the load queue.

fast speculative address generation and way caching for reducing L1 data cache energy.


our approach only requires checking one strided access entry.


A reference architecture on the other hand is a reference model mapped onto software elements that together implement the functionality of the reference model.

whereas reference modeling divides functionality, a reference architecture is the mapping of that functionality onto system decompositions.


In this section we consider the problem of detecting races in programs whose task graphs have a two-dimensional lattice structure.

we apply the algorithm for finding suprema from Section 3 in an efficient race detection algorithm.


Observe that the race detection algorithm in Figure 6 uses the result of a query only to compare it with the current vertex.

we may answer queries differently as long as any such sequence of comparisons leads to the same outcome.


As k increases, the state space to be explored by the BMC explodes exponentially.


The fixes of the previous iteration with the development of the current one are done simultaneously.

we can see that agile methods are iterative, emergent and flexible to cater changes in requirements differently as compared to the linear approaches of traditional software development [17][18].


A sequential specification of a deterministic object determines the return value of an operation from the sequence of prior operations applied to the object.

with a replicated object, operations executing at different replicas might have inconsistent notions of prior operations , e.g., because updates made on one side of a partition do not propagate to the other side.


One way, for example, is to ignore the received information (for a while).

a data store with invisible reads cannot do this (Section 5.3).


A fence event e forces the adversary to commit all the writes in p's write buffer (if any) in the order they were issued.

whenever the adversary schedules p, it commits the next write from p's write buffer, as long as the buffer is not empty.


Key idea is to take the advantages of both static and dynamic task mappings.

it refers to the pre-computed decisions on task mapping and schedule to pick best mappings for concurrent applications at run-time without heavy computation.


Co-locating and cooperatively scheduling multiple enclaves within a single node complicates the already difficult problem of node-level resource allocation.

for that, they enhanced the global EDF policy by scheduling the set of threads of the same application at the same time, only when there are enough physical cores available.


Exceeding this threshold means that the formula ϕ is not true in the transition system M.

satisfiability of [M, ϕ]k, for some k means that the formula ϕ is true in the transition system M.


Note that each key x can have many independent scores drawn, one for each element of x.

the more elements a key has, the more likely it is to be sampled.


The authors believe that this paper is the very first in nature to study explicitly productivity in agile.

section 3 presents the research design of the study.


Easily programming behaviors is one major issue of a large and reconfigurable deployment in the Internet of Things.

when the event is triggered, the context is embedded into it.


As future work, we intend to generalise the singular labels on labeled values and references to become sets of labels, thereby making them more homogenous with the rest of the enforcement.

like the current label set, these labels become elements in the power set lattice of security labels.


A closer look shows that TL is dominated by the time spent on maintaining the observation table (merging abstract states/transitions).

running the test cases only takes a small portion of the time.


Besides tools for predicate abstraction, there are tools of generating models for Java classes, among which we identify the TAU-TOKO tool [19, 20] to be bearing a similar goal as TLV.

in the following, we compare TLV with TAUTOKO1 in the context of answering the above research question.


In contrast, PPI greater than 1 indicates that CLOTHO generates many more constraints than those in the developer's fix.


In particular, the OpenGL ES libraries are vendor specific and not open source.

we cannot modify the source code and re-build the ROM.


However, this approach cannot save power because the GPU workload required to generate those graphics buffers remains the same and thus consumes the same amount of power.

we have to seek for a new approach and next we describe how our approach works.


Like many other Android-based smartphones, the OS is not fully open source.

the OpenGL ES libraries are vendor specific and not open source.


The number of AEGIS AWS programs participating during this metrics collection period was five.

each build served five different programs.


To achieve these benefits, one of the most important features of PLE is to provide an architecture that accurately captures the commonalities and variabilities of all the products in the product line family.

we narrowed down our analysis scope specifically to collect information required to build such an architecture and understand the current configuration process used at the company.


Moreover, the data transferred between such large applications is very huge and massive and hence the cost become high.

the cost needs to be minimized by minimizing scheduling length.


Queries can be executed on the source code or other relevant artifacts to, e.g., identify all classes that depend on particular other classes or packages [17].

to assess the architectural consistency, queries need to be written that identify forbidden dependencies.


Manually ensuring that the implementation of a software system is consistent with the software architecture is a laborious and error-prone task.

a variety of approaches towards automated consistency checking have been developed to counteract architecture erosion.


NDT maximizes the sum of probabilities that the aligned points of the second point cloud can score on this density [12].

as this database grows, so would the computational cost of finding a match, possibly making the splitting operation itself become the bottleneck of our system.


Up to the first buffer flush of process 25 at about 140 seconds the communication operations (red) require little time, as can be seen by the share of red within white, which contains everything else within the application.

during the first buffer flush all other processes wait for process 25 to finish its buffer flush and engage in the communication operation.


We recall that different mitigation measures can be taken depending on the outlier score.

for each iteration, we plot the outlier score of the largest outlier detected in that iteration.


We reduce the false positive rate dramatically by using an elasticity parameter that learns during the first iterations of the execution and adapts dynamically.

then, we restarted the execution from the last checkpoint (i.e., time step 15,000), and we recorded the datasets of the execution at each time step for a corruption-free execution.


The main idea is to gather statistical information for the whole cluster of points.

we generate and monitor multiple distributions.


We monitor the application datasets during runtime in order to find simple behavior patterns and therefore predict an interval of values that represents an acceptable value.

we de not want to keep previous data for each data point of the dataset we are monitoring, which incurs a 100%- 400% memory overhead.


In designing the methodology and tool, the goal was to automate the tasks that require knowledge of MPI library internals and provide the user with easy-to-implement recommendations that could enhance communication performance by tuning MPI library parameters.

a study conducted at TACC shows that, as depicted in Figure 3, most of the MPI jobs do not use the entire memory available on a typical Stampede node (32 GB).


In our model, called statically bounded region serializability (SBRS), regions are synchronization free, intraprocedural, and acyclic [31].

regions are bounded at synchronization operations, method calls, and loop back edges.


Since there is no mechanism to return either a reference or a primitive type (corresponding to the any wildcard), the call to getValue() boxes the value returned.

the call introduces a silent performance regression, which is the cost of interoperability.


our technique detected 443 clone sets (45% of our results) that Bauhaus missed.

bauhaus (with threshold 50) was not able to detect our motivating example (Figure 1).


The theoretical framework of graph transformations provides a declarative, rule-based technique for modifying graphbased models such as program graphs [8].

a graph transformation rule consists of a left-hand side (LHS) and a right-hand side (RHS), both constituting typed graphs, i.e., program graphs in our case, conforming to a given type graph of the underlying modeling language.


Such an h-ordering consists of multiple h-groups, where each h-group consists of suffixes which share a common h-prefix.

we are shifting the array B by h positions to the left.


It is because a work-item should be fed from two successive banks.

a bank should provide data to two work-items.


In the 32-bit mode, successive 32bit (4-byte) words map to successive banks.

both OpenCL and CUDA support image processing mechanisms for GPUs to speed up processing one-, two-, or threedimensional image data.


We cannot infer any dependency on the ordering of the receives on the process.

we do not allow the sends to be reordered.


Given that, in our targeted application, each rank only communicates with a constant number of neighbors (independent of the system size), we created a layout of "disposable communicators" , each of which only contained two ranks.

assuming no collectives were needed, we created a communicator for every pair of ranks that had to communicate.


Consequently, in this experiment we engineer the set of failures injected so that they do not allow propagation delays due to local recovery to merge, and therefore the total overhead is the sum of the recovery overhead for each failure.

this experiment evaluates the worst-case local recovery overhead.


If the quotient is greater than 1, linked weak array mourning is faster by a factor equal to the quotient.

if the quotient is 3, this means linked weak array mourning was three times faster than regular weak array mourning given a certain array size and tombstone rate.


Linked weak array referents will be referenced strongly until mourning determines it is safe to make the linked weak array slots weak again.

whether traditional weak arrays should also adopt the ephemeron finalization convention merits consideration.


Further details about MC/DC variants can be found in [11], [12].


In this paper, we present a classifier that can identify potentially vulnerable commits with a significantly lower falsepositive rate while retain high recall rates.

unlike most existing tools for vulnerability finding, we don t focus solely on code metrics, but also leverage the rich metadata contained in code repositories.


Machine-learning and data-mining approaches have been proposed by several authors for finding vulnerabilities.

unlike most existing tools for vulnerability finding, we don't focus solely on code metrics, but also leverage the rich metadata contained in code repositories.


An attractive approach to saving energy in such applications is to defer the execution of delay-tolerant operations until a time when they would consume less energy.

introducing delays to save power may have a detrimental impact on the user experience.


CRM applications may save significant power by changing the timing of delay-tolerant operations.

operations differ in their degree of tolerance to delays, so the developer must carefully balance energy savings against user experience.


For instance, [11] used an audio database with manually labelled adjectives belonging to one of 13 categories and trained Support Vector Machines (SVM) on timbre, rhythmic and pitch features.

categorical representations of emotions have been criticised for their numerous restrictions [13, 2].


To adapt the notification mode to the phone position and the user's context, a first method could be to rely on the users.

our daily experiences show that users usually tend to forget it.


These intelligent schedulers allocate resources by predicting a task's future resource usage based on its past utilization.

memory behaviors are very difficult to predict.


A large proportion of energy savings comes from devicespecific hardware power management, e.g., displays have a lower-power mode, CPUs have low-power speed governors, and on-board peripherals can transition to low-power modes.

the tasks and devices involved in handling the wakeup event are extremely limited, essentially just those represented in the figure (as well as the networking device).


This can be achieved if the resistances of the batteries are proportional to the square-root of their DCIR-to-SoC ratios.

the RBL-Discharge algorithm seeks to allocate the currents y1,...,yN in such a way that the effective resistances of batteries are as much as possible proportional to the square-root of their DCIRto-SoC rates minimizing the total energy wasted through resistive losses.


The bendability, unfortunately, comes at the cost of other battery properties.

it is interesting to note that if the user had not gone for a run then the first policy would have given better battery life suggesting that the knowledge of an impending workload can help save energy in heterogeneous battery settings.


If it were possible to check eagerly that compile is correct, the monadic cast would produce a value of type option correct comp, and the client calling runc (? compile) would simply have to locally deal with the potential of failure.

this non-local impact of deciding to statically establish guarantees or defer them to runtime is contrary to the smooth transition path that gradual typing is meant to support.


Conventional designs of navigation systems mainly focus either indoor or outdoor navigation.

all of such mobile phones are equipped with the inertial sensors (accelerometers, compasses, and gyroscopes), light sensor, Wi-Fi module, GPS module, and GSM module.


However, directly hooking printk has one practical issue: the hook handler has to parse the input to printk, which is a non-trivial job (e.g., to interpret the semantic of format strings like "%x").

we look into the source code of printk and find a function cont_add that is invoked by printk and handles already formatted output.


We have proposed the idea of live migration based on-the-fly software emulation, which significantly advances the state of the art: it is analysis-flexible, supports closed source OSes, and uses modern hardware virtualization extensions.

there exist discrepancies between their handling of VM states, which cause the "resume" step to fail.


This confirms our previous argument that it is energy efficient to run memorybound phases on ARM and compute-bound phases on x86.

for a memory intensive application with a regular memory access pattern, it will still be energy efficient to run the application on x86.


For Korat, third-party code implementing these structures with their various operations is publicly available, making it possible to simply borrow existing implementations.

with CLP, not only is code unavailable, existing imperative code is so different semantically that it cannot be translated directly.


They usually generalize one identifier or statement at a time and re-run the search; if the search result degrades, they undo the generalization and try a different identifier or statement.

their generalization strategy is similar to the typical greedy search.


It is challenging to directly compare CRITICS with LASE, because LASE's template generation requires multiple examples apriori and is fixed, while CRITICS is an interactive tool that a human can iteratively configure a template.

we simulate a human-driven template configuration process in CRITICS.


The original RTED algorithm finds node-level alignment by calculating the minimum edit distance, producing many false positives.


At the same time, product quality was not sacrificed as the process ensures that all tests are ran at least once on all code changes.

we have to estimate how undetected defects would propagate through the development process and when they would be detected.


Software engineers use SPLs to increase software reusability and to rationalise software maintenance and evolution effort across a range of related products [3].

without automated support, this feature selection process is likely to be highly suboptimal: it requires the simultaneous satisfaction of multiple objectives, such as matching user preferences, minimizing product cost and satisfying technical feasibility constraints in feature spaces defined by many thousands of features.


Despite the promising results, it fails to scale to large FMs mainly due to the expensive twise coverage computation [14].

concretely, the spread configurations suggest that there are configurations in favor of each considered objective.


ReviewBot also added the ability to provide fixes; this fix system is completely decoupled from the analysis results themselves.

tRICORDER fixes are produced by analyzers, and our mechanism for applying fixes (from structured analysis results) is language-agnostic.


Formal software verification is the application of formal proof to guarantee the correctness of software behaviour.

the cost of formal verification is not well understood due to the relatively low number of successful large-scale applications.


Refine builds on AInvs, but we compute the proof sizes for Refine with respect to itself

proofs from AInvs do not contribute to the size of proofs from Refine.


Most lemmas make stronger assumptions than are actually necessary.

a lemma might have a concrete term where an abstract one will suffice: the statement 1 is odd is less general than the statement 2n + 1 is odd , which has an abstract term 2n + 1 in place of the concrete term 1 .


Finally, the statistical analysis of the co-factors' influence has highlighted that only the knowledge of the used libraries has a significant effect on the completeness (p-value=0.006), although it does not interact with the main factor.

people with higher knowledge of the used libraries perform better, independently of the availability of the code examples generated by MUSE.


MUSE's examples are meant to help developers to reuse a particular method, once they know it might help with the task at hand.

we envision MUSE to be used by developers for getting more precise information about the methods they want to use, after using one of the tools mentioned above.


MUSE selects from each group Gi of type-2 clone examples in the ranked list the one having the highest ss value.

after the selection process, each method in Pi is associated with a list of ranked and diverse code examples.


This study aims at providing a human assessment of the ranking and selection heuristics.

we formulate the following research questions: RQ1: Does MUSE s example ranking re.ect developers judgment of code examples representing groups of clones?


The objects (i.e., code examples) of our study are generated by MUSE for the same six systems adopted in Study I.

we randomly selected ten methods from each system for which MUSE generated at least one usage example.


If there are only a few intervals where the counter is observed to be problematic, the severity will be close to 0.

if the counters are violated many times, severity will have a value close to 1.


Today, CPU centric-benchmarks (e.g., SPEC and RPE2 [33]) are often used to map and compare CPU utilizations between different configurations.

such an approach provides no support for practitioners to understand the rationale for such regressions and cannot be used to compare other performance counters than CPU (e.g., I/O, threading and memory-related performance counters).


In our example, a user could quickly inspect and modify the schema and data in the provisioned database through a web-based UI.

the most reliable or popular posts often contain concise code snippets with implicit references to external dependencies and in-line placeholders for surrounding program context [3].


The greater the uncertainty inherent in a project, the more the project has to move from traditional approaches that are based on a fixed sequence of activities to approaches that allow to redefine the activities or even the structure of the project plan in midcourse.

as the project complexity and uncertainty increase, managers need to go beyond traditional risk management; adopting roles and techniques oriented less toward planning and more toward flexibility and learning.


In the above process, concolic testing partly tackled the path explosion problem by using abstraction and refinement [17], [16].

concolic testing cannot automatically figure out what code blocks should be abstracted and which sideeffects of those blocks should be treated as inputs.


Crowdsourcing enables a group of individuals to contribute towards solving a high-level problem.

a fundamental challenge is to break a high-level problem into a number of precise (or atomic) tasks [7].


Moreover, in that work we rely on the Speech Act Theory revisited and described in the book of Bach and Harnish [4] to guide the interpretation of text in terms of intentions.

in order to tackle the lack of data we have collected online discussions (in the domain of software development) annotated with intentions.


An estimate based on this suggests that a clear separation of view and controllers, and a strict view layer will save up to 15% effort when porting code to new rendering services.

it is likely to be somewhat lower since dependencies can also be indirect and bleed through the view layer.


Testing (4) on increasingly longer tracks shows that this probability slowly decreases, therefore cancelling the advantage of the starting player for longer tracks.

the probabilities are 0.5276, 0.5232, and 0.5188, for track lengths of 126, 252, and 504 spaces, respectively


Let us now consider a strategy that changes on the basis of the duration of the game.

let us assume that a player would be conservative for some turns (in order to accumulate armies) and then become aggressive.


The most commonly used approach for preventing piracy is code obfuscation, that is, making the code of an application more difficult to understand.

according to Sahin et al. [43], obfuscations techniques used on mobile applications are likely to impact their energy usage.


Nevertheless, we hope that the approach we followed helped this paper better reflect the views of researchers in the software energy consumption community.

li et al. [24] presented the first large scale study on the energy efficiency of mobile applications.


Participants were allowed to use any resource they liked.

participants spent 76% of their total time on documentation webpages or hovering over a method documentation.


Therefore, they do not necessarily reflect the effective complexity of source code.

they lead to inflated measurements of well-structured long functions that are actually reasonably simple to comprehend [11].


The developers who had made prior changes to files in a change under review had a higher proportion of useful comments in four out of the five projects (all but Exchange which shows marginal increases), but we did not see a difference in effectiveness based on the number of times that a developer had worked on a file.

comments from developers who had changed a file ten times had the same usefulness density as from developers how had only changed a file once.


One possible explanation for these results is that reviewers who have changed or reviewed a file before have more knowledge about the design constraints and the implementation.

they are able to provide more relevant comments.


Since these services are intended to be invoked by serverside components of applications, the keys themselves would ideally lay dormant only in server-side program memory and thus be inaccessible for users of the application.

many application developers choose to host their application source code publicly on repositories such as GitHub and BitBucket to incorporate contributions from the opensource community.


The feature model is widely used in the SPL community, but it does not support dynamic aspects.

the authors tried to add some properties, extensions or rules to model DSPLs.


C09 -Multiple Bindings: It is possible that an DSPL have multiple bindings.

this criterion evaluates whether the technique can model multiple bindings or not.


The extended workflow provides tailoring by the possibility to distinguish between mandatory and optional activities.

projects can modify the workflow depending on project size, complexity, staffing, timeline and priorities.


The inner details are hidden from view of an HPCC System Administrator.

the type of testing that needs to be performed on an HPCC system with the typical computing node/accelerator card arrangement, is often black-box regression testing.


After the first phase, the main results were published in [1].

doing this within the walls of the organization ignores all the opportunities for open innovation around the best practices to software engineering.


One limitation in the modeling process was the scalability, especially when having numerical computations.

the problem has been solved by delegating a part of the functionality to the adapter.


It cannot control the behavior of the IUT via test inputs; it can only observe its behavior.

we discuss the benefits and limitations, and propose a concrete solution to address the latter.


While such design decisions pose important limitations discussed later in Section V-D, we were able to control the same information patch for analysts to pursue the correct traceability links [10].

a unique tag, personnel , helped one analyst to make the correct decision of selecting PersonnelDAO.addEmptyPersonnel() in the final TM.


In the last decade, Information Retrieval (IR) has been widely adopted as core technology of semi-automatic tools to extract traceability links between artefacts according to their textual information.

a widely known problem of IRbased methods is that some artefacts may share more words with non-related artefacts than with related ones.


The improvement gained by the adaptive feedback is particularly evident for Easy-Clinic, while for MODIS and i-Trust there is more interleaving between the two feedback strategies.

for i-Trust the adaptive feedback is substantially better than the standard feedback only for recall lower than 50%, while for MODIS the two corresponding precision-recall curves are very similar.


GCP provides application programming interfaces to make it easy for developers to specify how to handle these inevitable false positives.

it is possible that an incorrect value is returned for an attribute that was never inserted, i.e., the query returns a false positive.


Thus, the continuous time and space domains are discretized so that a set of numerical computations are iteratively (time discretization) applied onto a mesh (space discretization).

in a mesh-based numerical simulation, the PDEs are transformed to a set of numerical computations applied at each time step on elements of the discretized space domain (the mesh).


A stencil kernel computes the value of one data or a subpart of it (the kernel computation domain ) using a numerical expression which takes as input one or more data.

for example, the stencil kernel illustrated in Figure 1b computes A using B, while the one in Figure 1c computes A using C. a stencil kernel is defined by its numerical expression, a set of input data (only one in the examples), and its unique output data, the result.


The Tree Decomposition: Gtsp Many works [21, 24] explains how to build a series-parallel tree decomposition from a minimal series-parallel graph.

as mentioned in the previous section, the Multi Stencil Language (MSL) is an agnostic descriptive language for multi-stencil simulations.


Typically, each FW task repeatedly provides a service, with a clear start and end, in response to inputs from its interacting SW or HW layer.

in this setting, FW code is inherently associated with an infinite loop structure.


After O2 is generated at step 2, the Nursery Region is full.


Data flow 5 indicates that, at the appropriate time, the valid log records will be effectively written to the file system.

the system only needs to update the delta 2 + delta 3 based on L1.


However a compute node may appear in one or more trees because it may be few hops away from multiple bridge nodes.

once all the trees are formed, we examine each tree rooted at a bridge node to decide the new assignment based on the distance from bridge node by invoking Traverse (line 7), which we outline in the next section.


Local accesses to the ob ject then make use of this data unless rget is subsequently used or the entry is evicted.

the object s origin and address are stored, along with a local pointer, in a concurrent dictionary which is consulted for future lookup and removal operations.


In that view, variables must be renamed to match the mechanisms of lexical scope as macro expansion proceeds.

all of these benefits reflect the way that scope sets are precise enough for specification but abstract enough to allow high-level reasoning.


At the same time, the needed cache capacity should also be exploited to alleviate the PCM endurance concerns.

we set the DRAM size as 1MB, 4MB and 16MB to represent the small, middle, and large cache configurations respectively.


Today's machines are incorporated with specialized hardware units, such as DFP, SIMD, FPGA, and GPU, to complement diminishing singlethread performance improvements due to silicon technologies.

the original binaries are compiled with COB42 with the highest optimization-level in Fig. 9 and the lowest optimization-level in Fig. 10, respectively.


This presentation was followed in particular in the original paper on Separation Logic [14].

we introduce the representation predicate p -> Queueof R L, to assert that, at address p in memory, there exists a mutable queue represented by the list L, when the elements stored are represented by the representation predicate R.


Furthermore, it became obvious that system features encumber the interactions.

system level features from Android (such as the main app menu) repeatedly opened during the VI users exploration of the screen with their fingers.


Norman [36] observed that a key feature that distinguishes an activity-centred approach from others (e.g. user-centred) is that it requires both a deep understanding of users, and also of the technology, the tools, and the context of the activities.

an activity-centred approach provides a better fit to understanding group activity in multi-surface spaces, as a whole.


For example, the activity-based computing (ABC) framework [2] is conceptually close to the ACAD framework in the sense that it decomposes users activity into tasks, materials, time, and users.

the purpose of the ABC framework is to inform the implementation of 'computational activities' of a distributed system that ensures adequate synchronisation of data and methods across devices.


In contrast, some of the character array and intrinsic array types were not modified inside the called C function.

their general approach is to use a model for representing facts about different programming languages and link facts between the host and foreign languages.


Like Felix, HONE uses end hosts to implement certain measurement tasks.

hONE lacks abstractions for expressing, analyzing, and partitioning network-wide queries based on regular expressions.


The tool located several explicit call locations within test classes.

it did not locate implicit calls that originated from HTML pages.


CLOUDIATOR differentiates between cloud platforms, the API offered by a software stack, cloud provider, the organisation running a cloud platform at a dedicated endpoint/URL, and cloud, as the offering seen by the tenant.

besides the endpoint of the provider, a cloud is also linked to log-in credentials.


Layers are identified only via their name, but a reified Layer object will be created lazily once a symbol is being used as layer name.

this cannot be considered a sandbox, since a locally active layer can still cause global effects.


We propose a method to detect invalid combinations between layers that occur at runtime using static analysis.

even though several COP languages activate layers in disciplined manners, e.g., using scoping (6) or composite layers (5; 11), such activation mechanisms do not prohibit layer activation that is mistakenly specified by the programmer.


The approach presented here is novel in investigating whether Erlang has the potential to address the scalability and reliability issues with communication between ROS nodes.

we don't replace the entire Robot Operating System, only the communication layer.


Traditional WSAN networks such as WirelessHART employs a uniform routing strategy across an entire network.

if the operator chooses graph routing, a graph routing protocol will be used for all flows in the network.


The statistical distributions are based on all bidirectional links in the topology with 500 transmissions per link.

s/G (3 Hz) is at the second best, which con.rms the impact of control frequency on system lifetime.


The entries in the same row are the blocks that were written when the snapshot was created.

in all these cases, accessing older versions can provide superior latency and/or throughput.


In this paper, we propose a more compositional fragmentoriented approach to the problem of expressing new semantic structures.

we introduce a single extensible statically typed language, typy, that gives library providers the ability to define new semantic fragments.


Their approach automatically checks whether a configuration exists in which a referenced identifier is never declared.

in contrast to our approach, they are only concerned with the existence of declarations, but not with the resolution of a particular reference to multiple suitable declarations.


Considering that the system control of each system is concentrated on its owner, the developers of the systems integration is strongly dependent of such systems owner.

there is a clear need of a change in the approach in the direction of having well-defined standards and protocols to allow developers to integrate such systems in an easy way.


As this version of Segen was developed to generate test scripts for Selenium and Selendroid only in Java, we used a library to generate code in Java called JavaPoet4.

the architecture of Segen has been prepared to add, in the future, generators of scripts in other languages.


An advantage we observed is that Segen does not need to be the only tool used to test the user interfaces versions of an application.

any component that cannot be tested by Selendroid and Selenium can be tested separately by other tools, including those ones used by Segen, such as JUnit and other Java libraries.


Additionally, when a task is decomposed into (nearly) independent subtasks, community members can complete them (mostly) in in parallel.

partitioning a task also creates overhead for coordinating the execution of subtasks.


In contrast, we work with seven to ten children over longer periods of time.

our priority is examining closely how the adultchild interactions support direct democratic practices, in which choices and decisions are made directly together during design sessions.


It saves one communication phase where all replicas send messages to each other; hence it spares network bandwidth and reduces end-to-end latency.

as can be seen, HybsterS is the only configuration confined by a sequential ordering protocol.


Upon engaging with a community and depending on an open source software for its own products and operations, an organization has the choice to take on extra responsibilities in the community to preserve it and ensure that the valuable communal resource is maintained [23].

the organizational-communal engagement involves a selection process that can impact both the open source community and the organizations.


In contrast, The VMXOFF instruction makes the processor run in the VMX non-root operation.

we execute the VMXOFF instruction upon devirtualization and the VMXON instruction upon revirtualization.


As BitVisor changes from the source host to the target host, the address of the virtio ring buffer also changes.

we must transfer the address of the virtio ring buffer.