id
stringlengths
7
12
sentence1
stringlengths
5
1.44k
sentence2
stringlengths
6
2.06k
label
stringclasses
4 values
domain
stringclasses
5 values
train_126900
For example, Greenwald constructs a basic hash table implementation in which processes regis­ter operations in the header of the hash table.
every process wishing to insert an element must .rst complete any other active operation before beginning its own, even if the operations access distinct buckets.
reasoning
Software and its engineering
train_126901
I, do if A is an atom of a tabled predicate with mode last I0 + (I0 U {A}) - {A1 = I : K(A1 ) = K(A)} (*) else I0 + I0 U {A}; 3. return I0.
the .xed point semantics of P can be described as TP .
reasoning
Software and its engineering
train_126902
Since Pattern 8 a.ected the Feature Model, one may now look up, which pattern ad­dresses change in Feature Models.
pattern 7 is relevant causing the existing Feature Model Con.gurations to be updated.
reasoning
Software and its engineering
train_126903
The data .ow analysis frame­work[24] of aiT hasbeeninstantiatedtoperform .xedpoint iteration on the symbolic representation.
the integra­ (.T.b, .b Algorithm 3: DoBlock+A.b ,b) the blocks correspond to the enumeration of the relevant instructions at b3 and b5 respectively.
reasoning
Software and its engineering
train_126904
(p(Base) .p(GetPop Base)) SAT solvers ef.ciently verify existential clauses for proposi­tional formulas [27].
we transform constraint (2) into a theorem to be veri.ed by a SAT solver.
reasoning
Software and its engineering
train_126905
Also, the representation of a database-driven application must clearly indicate the cou­pling points between the program and the entities within the database [12].
the calculation of any test ad­equacy metric for database-driven applications requires a uni.ed application representation to select defect-revealing test cases from an input space that is essentially in.nite.
reasoning
Software and its engineering
train_126906
Moreover, memcached can also be distributed on several machines, so that request workload can be automatically distributed among all instances.
as one of our next steps we will test a parallel/distributed deployment MoSoGw and precisely assess its scalability.
reasoning
Software and its engineering
train_126907
The gray nodes can be eliminated safely because their children contain all information.
the actual, minimized footprint graph is only eight nodes in size.
reasoning
Software and its engineering
train_126908
movbe (move big endian) instruction introduced in the Atom pro­cessorfamily [19].
it makes sense to investigate further ISA extensions to support IA s breakthrough into these markets.
reasoning
Software and its engineering
train_126909
Through extensive Wi x=1 Pi(x)x experiments, we found that the quantity PWi is a good met­ric for measuring the uncertainty of task Ti.
we sort the tasks in increasing order of this metric before applying the algorithm in Figure 1 and execute the tasks in the same order during each frame.
reasoning
Software and its engineering
train_126910
Detail information on the fortress is also given at the fortress site such as the complete plan of the original fortress and some background history.
the experience of being at the fortress site provided better understanding of how the fortress might actually looked like rather than just looking at the pictures of the fortress.
reasoning
Software and its engineering
train_126911
Our experiment indeed shows that the majority of loads that can benefit from stride prefetching are inside loops with high trip counts (see Section 4).
restricting profiling and prefetching to in-loop loads with high trip counts does not impact the performance.
reasoning
Software and its engineering
train_126912
Likewise, given a TO instance t, we get its FROM instances via to(t).
from() enables forward traversal, while to() gives backward traversal.
reasoning
Software and its engineering
train_126913
It is now possible that both T3 and T4 read the old values of Y and X respectively (from their caches), violating sequential consistency.
while previously the read-others -write-early restriction appeared to have (acceptable) implications only for the main mem­ory system and the cache coherence protocol, new SMT and multi­core architectures move this restriction all the way to the .rst level cache and even within the processor core (if there are shared store queues).
reasoning
Software and its engineering
train_126914
For in­stance, caller plus web have composed overhead of (1.8 - 1) + (1.11 - 1) = 0.91 on average.
this composed method is 1.91 times slower than the baseline.
reasoning
Software and its engineering
train_126915
more than the number of cache regions in the LLC), in each time period, cache pollution is limited within a few cache regions because consecutively accessed blocks are usually correlated and are in same sequences.
most cache regions can still be ef.ciently used without suffering from cache pollution at any time.
reasoning
Software and its engineering
train_126916
The impact of position inaccuracy y is more severe in High Concurrency Protocols with Slow wdown (HCPS) of STIP protocols, since this group of f intersection protocols explicitly utilizes information rrelating to a vehicle's progression inside the intersection area.
a failure in locating a vehicle's current ce ell information correctly may lead to vehicle collisions insiide the intersection grid.
reasoning
Software and its engineering
train_126917
On the other hand, every node only receives O(EL) requests within 9 rounds.
the maximum rate that can be sustained is T(E/((1 - E)En)) = T(1/((1 -E)n)).
reasoning
Software and its engineering
train_126918
The same approach could be used by the sender.
send only the values of the data that has changed from the previously sent data values rather than all the data.
reasoning
Software and its engineering
train_126919
In distributed control systems, calculations are distributed to multiple processors.
if a parameter value is needed from another module, the engineer has to add an external data point symbol to the program.
reasoning
Software and its engineering
train_126920
Unfortunately, it has no replay facility.
when there is nobody home, messages are lost.
reasoning
Software and its engineering
train_126921
[42], we model loss using a two-state Gilbert model [17], setting loss rate to 1% and mean loss burst time to 100 ms. 7.1.3 Performance metric As discussed in §2.1, lag is the most important network factor that a.ects player enjoyment and performance.
the primary performance metric we measure is percentage of required updates that are received on time.
reasoning
Software and its engineering
train_126922
Preliminary evaluations on hundreds of fragments showed that if a fragment ever .nishes, it .nished within 0.2 second.
we set the limit to 0.5 second and kill the process if it exceeds that limit, and the output of the execution is marked as a failure for later use.
reasoning
Software and its engineering
train_126923
They typ­ically use the EIP register to indicate where in the applica­tion should the kernel return control to.
when BIRD intercepts the return instruction of an exception han­dler, it uses the EIP register rather than the return address as the target of the return instruction and invoke the dynamic disassembler if the target happens to fall in an UA.
reasoning
Software and its engineering
train_126924
Functional languages allow a new function to be added to an ex­isting datatype.
eML must allow a new function to be added to an existing class.
reasoning
Software and its engineering
train_126925
Our reverse engineering set of tools will be able to recreate the traceability links between the robustness model objects and the implementation classes, based on the execution trace that correspond to the steps of the scenarios.
our environment must support use-cases, scenarios and robustness diagrams editing.
reasoning
Software and its engineering
train_126926
In older schemes, which used heap based alloca­tion of stacks [4, 14], the activation records are allocated on the heap, and explicitly deallocated when the procedure returns.
no task runs out of memory, unless there is no space left globally.
reasoning
Software and its engineering
train_126927
In experiment, each node represents one autonomous VO, in which 40 resource nodes and 40 kinds of application services are simulated.
the maximum identifier space is 25×80 (2,000).
reasoning
Software and its engineering
train_126928
2.1 Participants We focussed on organizations that potentially had the option and resources to conduct usability evaluations.
we wanted Copyright 2008 ACM ISBN 978-1-59593-704-9.
reasoning
Software and its engineering
train_126929
The main idea of Informatization is to set up government association and industry Informatization based on ARP, instead of separated information.
there will be more solution in virtual governments; virtual enterprises unfixed enterprise link and virtual resource association.
reasoning
Software and its engineering
train_126930
It is '' '' possible to apply Avoine's scheme for UD(pcom,X ,Y '' ,f ) (which we call Avoine's dynamic scheme), but it cannot uti­lize the older result of pcom, and needs a heavy calculation as evaluated in Section 5.
to design a secure iden­tifcation scheme with efcient update is a crucial challenge in large­scale RFID systems.
reasoning
Software and its engineering
train_126931
Trapezoids are executed in the form of thread blocks whose execution do not interfere with each other except for device memory accesses; when multi­ple memory requests are issued in bulks by multiple thread blocks, the requests are queued in the device memory and a thread block may have to wait for requests from other thread blocks to complete before it continues.
the latency in the device memory accesses (MemAcc) needs to consider the joint e.ect of memory requests from all thread blocks, rather than be regarded as part of the parallel exe­cution.
reasoning
Software and its engineering
train_126932
On the other hand, there are still only .nitely many choices for a node n, namely the number of members in the class of n, that is, |classn|.
to produce a new criterion for trivial col­orability, we must .nd a measure of the constraints imposed on n by n s neighbors, and this measure must be comparable with the number of choices |classn|.
reasoning
Software and its engineering
train_126933
During its initialization phase, A builds a small set of information on connectivity parameters (e.g.
one-way delay) towards other peers, then it associates with an existing super-peer S, and upload this set to S. each SPAD super-peer receives and stores connectivity parameter (CP) information from its associated normal-peers.
reasoning
Software and its engineering
train_126934
As mentioned above, the capturing device needs a certain amount of time to process a tag.
if too many tags are required to present the required information, capturing the tags becomes less user-friendly.
reasoning
Software and its engineering
train_126935
The .rst is stored inside the containing entity s table, the second is stored in its own connection table.
acoda provides three dif­ ferent coupled operators for property creation: one for value prop­ erties, one for single-valued associations, and one for multi-valued associations.
reasoning
Software and its engineering
train_126936
Since the lock on writeLock is held by T1, it gets blocked.
t1 is waiting to be noti.ed by T2, and T2 is waiting for T1 to release writeLock.
reasoning
Software and its engineering
train_126937
To provide reproducible results, the traces must be run on a sin­gle .le-system image.
the iBench suite also contains snapshots of the initial directories to be restored before each run; initial state is critical in .le-system benchmarking [1].
reasoning
Software and its engineering
train_126938
This could allow the move­ment of one or both of the accesses mentioned in Section 3.1.1, into an overlapping region of execution.
the fewer the interesting synchronizations among Usync, the more the unaffected statements in user code, and so the less the chance of two procedures immedi­ately interfering as a result of a data-.ow transformation.
reasoning
Software and its engineering
train_126939
Giventhe destructive potentialofbuggy.lesystems,itiscritical thaterrorpropagationpatternsbe carefullyvetted.However,failures in the physical layer, while inevitable, are rare enough in daily use that traditional testing is unlikely to bear fruit.
we propose a static analysis to identify certain common classes of error mismanagement.
reasoning
Software and its engineering
train_126940
Executing a plan means invoking each service that compose it according to the execution process defined in the workflow that have originated this selected execution plan.
openCOPI orchestrates the invocation of each service.
reasoning
Software and its engineering
train_126941
The decision ta­ble of the OSS algorithm contains 15256 elements, while the threshold table of the OSSL algorithm only has 4920 ele­ments.
the OSSL algorithm runs much faster than OSS: less than 200 msecs versus up to 44 secs.
reasoning
Software and its engineering
train_126942
We added support in the front-end for generating call statements with non-contiguous actual arguments, sinceordinarilyonlyabaseaddressisused.Inthesecondcase,the front-endwillordinarilyrepresentallassumedshapearraysasdope vectors.
it will create a dope vector in the calling func­tion, initialize it to point to the section of data that is being passed, and replace the actual argument in the call statement with it.
reasoning
Software and its engineering
train_126943
This information is suf.cient for our simpli.er to assert that ss is non­empty.
the calls (head_1 ss) and (tail_1 ss) are safe from pattern-matching failure.
reasoning
Software and its engineering
train_126944
Furthermore, a person may not know the email address for the individual he or she is seeking, since one purpose of an OSN is to reconnect mem­bers with out-of-touch acquaintances.
people need to rely on other biographical features to locate their friends, resulting in a search process that is much less precise.
reasoning
Software and its engineering
train_126945
Every path in G{ corresponds to a path in the burdened dag Gb, except that G{ omits overheads for continuations that are not stolen.
we have T8{= Tb8.Since we only have a migration overhead when a continuation is stolen, thetotal amount of overhead in G{ is at most dPT8{+ O(Plog(1/e)),from which it follows that T1{= T1 + dPT8{+ O(Plog(1/e)) = T1 + dPTb8 + O(Plog(1/e)).
reasoning
Software and its engineering
train_126946
In particular, it does not satisfy the third property because its value is dependent on the old values in the in­put buffer trans that were read in iterations prior to the current one.
without the declaration of balance as a global variable (which would cause it so satisfy the second property), the three .ner-grained services would be not identi.ed.
reasoning
Software and its engineering
train_126947
For each slot, the af.nity cost is assigned in a way that a higher cost is given as the distance from Y increases.
the scheduler prefers slots that are close to Y and (3,11) is selected.
reasoning
Software and its engineering
train_126948
Such an embedding would add expressive power but would arguably also forego separation of concerns, increase complexity, and decrease chances for automation.
this paper attempts to get by without a logical embedding approach by supporting common pro­gramming idioms directly.
reasoning
Software and its engineering
train_126949
Consequently, the total request rate expe­rienced by the MDS depends on the meter reading rate on each individual concentrator.
j concentrators can deliver the same request rate q of j/2 concentrators where each deliver 2q request rate.
reasoning
Software and its engineering
train_126950
Finally, since AOSE methodologies often have to deal with many di.erent kinds of WorkProduct and relations among WorkProducts and ac­tors, one further addition to SPEM could be a mechanism for the management of the representation complexity similar to the SODA layering principle.
in the future we also plan to test SPEM in other contexts, like for instance Aspect-Oriented Software Development [10], with the purpose of devising a possible SPEM extension that makes it general enough to potentially model any kind of process, independently of the computa­tional paradigm adopted.
reasoning
Software and its engineering
train_126951
In DCAS, the primary fo­cus of adaptation mechanisms is recovering from situations in which the system is running under the acceptable levels of performance.
in this case we identi.ed potential sources of system states in which anomaly rpsViolation holds.
reasoning
Software and its engineering
train_126952
22 These conditions guarantee that the data spaces of any two processes cannot overlap.
we think of programs in the universe model as a set of mostly independent sequential processes.
reasoning
Software and its engineering
train_126953
In the capability model, possession of a capability to some object is sufficient to use that object, and the reference distribution graph is at the heart of the security policy.
a permission is encapsulated as a capability, and the complete set of system permissions is given by the system s reference graph.
reasoning
Software and its engineering
train_126954
2.1 Property 1: Task-based An EPL representation must retain information expressed by many different programming models.
it must offer a univer­sal mechanism for representing parallelism.
reasoning
Software and its engineering
train_126955
Let y .P be the head of the semi-strong path q.
we know that there exists a semi-strong path q from A to B such that the strong path from y to A (as well as the strong path from y to B)is honest if (any sub­set of ) the second set in Ais corrupt and is fail-stop corrupted if (any subset of ) the .rst set in Ais cor­ 4The exact probability analysis is easy and very similar to the one done for the Information-Checking Protocol of [11].
reasoning
Software and its engineering
train_126956
5.1.1 Form relations extraction The forms either permit the updating of relations in underlying database or represent a view that is often a joint of relations.
each field entry is generally linked to an attribute of one relation in the underlying database.
reasoning
Software and its engineering
train_126957
Viewing the operating system as an immutable object is clearly at odds with the bulk of operating systems research, which seeks to develop and integrate new ideas into operat- ing systems themselves.
to reduce the efforts required to change the OS, a large body of research has investigated how the operating system should be restructured so that it is eztensible [8, 13, 15, 35].
reasoning
Software and its engineering
train_126958
However, the efort of compiling a region of code is only worth if the code is frequently executed otherwise, the compilation overhead outweighs the reduction of the exe­cution time achieved through the compiled code.
a technique known as Selective Compilation is employed in several Java Virtual Machines [11, 9, 10].
reasoning
Software and its engineering
train_126959
Our approach implies frameworks to have more entities, due to the existence of the specialization aspects.
one may be concerned with scalability issues when applying the technique to large frameworks.
reasoning
Software and its engineering
train_126960
However, both memory ports are used at modulo cycle 1 by the two loads of the original loop code iteration.
we have to move the load one cycle back in the schedule to cycle 9.
reasoning
Software and its engineering
train_126961
As all the semantic actions are introduced to the AST node classes, there is only one class hierarchy created.
during tree iteration, object-oriented polymorphism is sufficient to determine which node s processing method should be invoked at runtime.
reasoning
Software and its engineering
train_126962
Another major drawback of the if-solution is that the compiler cannot optimize away arithmetic loops.
we did not use it in our implementation.
reasoning
Software and its engineering
train_126963
On the other hand, if some node announces a mismatch in step 2, then Dispute Control will be performed, which will result in correct outcome for the broadcast of the k-th instance.
in all cases, NAB will lead to correct outcome in each instance.
reasoning
Software and its engineering
train_126964
Running Example The Comparison Component in this step is refactored to support annotations created by the application.
the application is able to create annotations related to its domain, which can also be used by other frameworks and components.
reasoning
Software and its engineering
train_126965
The compute time is almost completely consumed in the base blocks which is a generic multiplication on matrices of dimensions 32 × 32 or smaller.
these performance results show how their iterative algorithms could perform for small matrices if the Morton-indices would have been computed incremen­tally instead of by dilation.
reasoning
Software and its engineering
train_126966
Since L Pi Pi L Pi = Di, f monotonically decreases with L. Furthermore, notice that if L = Di, Ci(0,L)=0 because no job has a critical time earlier than Di.
it is suf.cient to con­ / sider the case of L= Di, where f =Ci Di.
reasoning
Software and its engineering
train_126967
Finally, in some studies the question was Not used directly to guide the search for primary studies.
the studies were also classified according to the use of the research questions as: PICOC, Search terms, and Not used.
reasoning
Software and its engineering
train_126968
Unless a proof of correctness is constructed, it is impossible to determine exactly how many faults exist within a program.
different tests have been developed to capture different tool abilities.
reasoning
Software and its engineering
train_126969
This behavior is explainedbythefact thatF-AODVminimizes the number of nodesthatparticipatein communications usedby F-AODV which in turn causes a low probability of contention.
f-AODVcanaccommodate morepacketdeliveryinthiscase by reducing the number of collisions using a low number of FNs.
reasoning
Software and its engineering
train_126970
Thus, there is a winner of chain 0 which is active at the end of o~m+l and has location 0.
there are at most k - 1 processes with locations 1,... , oo at the end of am+l and the claim holds.
reasoning
Software and its engineering
train_126971
The over­head due to the run-time checks is proportional to the num­ber of invocations of overlaid functions.
to generate an e.cient overlay structure for a given memory size, we need to minimize the overhead due to the runtime checks.
reasoning
Software and its engineering
train_126972
How­ever, for many e-commerce applications, content is created dynami­cally based on the current state of a business, such as product prices and inventory, rather than static information.
content delivery by most CDNs is limited to handling static portions of the pages and media objects, rather than the full spectrum of dynamic content that constitutes the bulk of the e-commerce Web sites.
reasoning
Software and its engineering
train_126973
Other iterations to step 3 of the above algorithm will further remove the layers, one per iteration, until it reaches to the top two layers wherein all interactions are identified.
the number of iterations required to identify all the interactions will be n-1 , where n is the number of layers.
reasoning
Software and its engineering
train_126974
Fortunately, inspired by Simon s ant[2], we also realized that though single node s intelligence is negligible, if nodes can be programmed properly, the intelligence shown by these collections of nodes is strong enough to accomplish some complicated tasks.
to addressing the self adaptation problem of whole sensornet, we can start with programming single node to enable it self adjustable.
reasoning
Software and its engineering
train_126975
In some systems faults may cause human injury, in others loss of money.
to increase understanding, analysability and testability of systems, simplicity and static solutions is prioritised in many design decisions.
reasoning
Software and its engineering
train_126976
Maximally-sharedgraphsprovide severalbene.ts: Node ni is reachable from node nj if and only if nj is data­dependent on ni.
irrelevant sub-expressions are au­tomatically sliced away.
reasoning
Software and its engineering
train_126977
METHODOLOGY OVERVIEW The starting point of the methodology is a system com­posed of a RTL IP-core (device) and the related testbench (see top of Figure 1).
the RTL testbench tests the IP func­tionalities: it is assumed to be correct and complete.
reasoning
Software and its engineering
train_126978
As a consequence of this synchronization, s is added to the set S of nodes logged in I and s ~ is replaced with $ within P. Operation Iogout(1) disconnects the executing node, say $, from £.
s is removed from the set $ of nodes logged in I and any alias for s is removed from the allocation environment of £.
reasoning
Software and its engineering
train_126979
In conclusion, none of the existing approaches meetallthree requirementswhich wediscussedinSection3.
wewillpresent ourapproach that satis.esthe three requirements in the following.
reasoning
Software and its engineering
train_126980
A model field is an abstraction of one or more concrete fields.
model states must be accompanied by a represents clause that defines whether the object is in that state in terms of concrete Java fields.
reasoning
Software and its engineering
train_126981
Con­ 2045 sequently, components are arrows between interfaces and so arrows between components are arrows between arrows.
three no­tions have to be taken into account: interfaces, components and component morphisms.
reasoning
Software and its engineering
train_126982
Visiting a point in the fault space incurs a certain cost corresponding to the generation of a test, its execution, and the subsequent measurement of the impact.
ideally, one would aim to visit as few points as possible before .nding a desired fault.
reasoning
Software and its engineering
train_126983
whose kth bit is set to1 if f accesses (a data element from) .k; otherwise, it is set to 0 (note that all iterations in an iteration block access exactly the same set of data blocks).
the tag associatedwith an iteration block summa­rizes the data access pattern of the iterations it holds.
reasoning
Software and its engineering
train_126984
Scalileo uses a bootstrap proce­dure to acquire new nodes.
no installation or con.guration is required on previously unused nodes.
reasoning
Software and its engineering
train_126985
µF negNorm = [trans]D Q0 2.5 In.nite State Space The Haskell representation of DTTs generalises the de.nition of DTTs as it does not put any restriction on the state space: the state space q in the type TransD fq g does not have to be .nite.
we can express transformations that go beyond DTTs in the traditional sense, e.g.
reasoning
Software and its engineering
train_126986
3 cannot change the nondeterministic behavior of the original pro­gram.
it does not include an abstract cost to mea­sure the amount of nondeterminism.4 Due to this fact, the current RLNT calculus enjoys the following property: for each residual rule r, the associated costs in the original and residual programs, (k, k ' ), have exactly the same structure (i.e., the same number of alt constructs and in the same position).
reasoning
Software and its engineering
train_126987
3.1.2 Attribute De.nition A collection of synthesized or inherited attributes is an extensible record, too.
for each ATTR declaration in the .agi .le, a label has to be generated to refer to the de­.ned attribute.
reasoning
Software and its engineering
train_126988
Here it has to know how much of the remaining code of the caller to copyback.
an address consists not just of an offset (relative to the startof the green zone)but alsoa sizein bases.
reasoning
Software and its engineering
train_126989
All elements, models, and transformations between these levels have been continuously and uniformly specified thanks to a single UIDL: UsiXML.
this transformational approach is su­perior to existing approaches in that all the design knowledge that is required to conduct the transformations is explicitly given in transformation rules.
reasoning
Software and its engineering
train_126990
Myriad techniques to decrease dynamic processor power are also emerging.
processor power may increase only slightly or remain stable over time.
reasoning
Software and its engineering
train_126991
Even though the recall measures were not 100% for all the features, they have presented high accuracy in the recovery of feature code.
it seems that our proposal for forward recovery provides developers with a reasonably-reliable way to understand the program family evolution (Section 3).
reasoning
Software and its engineering
train_126992
By having the product line mapping more fine grained this problem could be resolved.
we found the structural match between software architecture and the product line mapping result to be very good.
reasoning
Software and its engineering
train_126993
Then, the (.eld) referencing level from Oi to Oj is n, the number of .eld references needed to reach Oj from Oi, i.e.
oj is reachable from Oi at (.eld) referencing level n. in Figure 1(b), the referencing level from A to E is 2.
reasoning
Software and its engineering
train_126994
For example, in Figure 9(b), variable u and w have two different val­ues in subspaces 1 and 2 respectively while v is only updated in subspace 1.
subspace 1 is the one that contains all the three variables, subspace 2 only contains u and w. Since the values of variables a and b are not affected by speculative values, these vari­ables do not exist in any subspace.
reasoning
Software and its engineering
train_126995
The most important observation here is that: Having cor­ing as post-processing to sk-strings removes not just erro­neous transitions but also quite a fair number of correct transitions.
the accuracy of the mined spec­i.cation degraded.
reasoning
Software and its engineering
train_126996
In particular, feature models have been mapped to Core Com­ponents which is a prerequisite for deriving business docu­ments utilizing feature models.
in the following we sketch our approach for deriving context-speci.c busi­ness documents while utilizing feature models, as illustrated in Figure 8.
reasoning
Software and its engineering
train_126997
Moreover, the parallel intermediate delay is equal to the minimum possible delay because an intermediate computer must transmit the command to the next destination, and the delay captures the time requires for the transmission.
overall, the model predicts that when multiple cores are available for scheduling, the parallel multi-core scheduling policy should always be used.
reasoning
Software and its engineering
train_126998
Because reachable memory usu­ally grows more slowly than the allocation rate, allocations trigger more and more collections as memory .lls the heap.
we support two options: (1) moving to PRUNE when the heap is still 100% full after a collection and the VM is about to throw an out-of-memory error or (2) moving to the PRUNE state after .nishing a collection in the SELECT state.
reasoning
Software and its engineering
train_126999
We utilize the fact that we need to preserve the old contents of a .le only if they were read.
we up­date the PFile structure to track the upper and lower bounds of the .le positions that program actually reads.
reasoning
Software and its engineering