Mercurial > hg > Members > kono > jpf-core

comparison src/main/gov/nasa/jpf/vm/GenericSGOIDHeap.java @ 0:61d41facf527

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial v8 import (history reset)
author Peter Mehlitz <Peter.C.Mehlitz@nasa.gov>
date Fri, 23 Jan 2015 10:14:01 -0800
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:61d41facf527
1 /*
2 * Copyright (C) 2014, United States Government, as represented by the
3 * Administrator of the National Aeronautics and Space Administration.
4 * All rights reserved.
5 *
6 * The Java Pathfinder core (jpf-core) platform is licensed under the
7 * Apache License, Version 2.0 (the "License"); you may not use this file except
8 * in compliance with the License. You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0.
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18 package gov.nasa.jpf.vm;
19
20 import gov.nasa.jpf.Config;
21 import gov.nasa.jpf.util.IntTable;
22
23 /**
24 * abstract Heap trait that implements SGOIDs by means of a search global
25 * Allocation map and a state managed allocCount map
26 *
27 * NOTE - a reference value of 0 represents null and therefore is not a valid SGOID
28 */
29 public abstract class GenericSGOIDHeap extends GenericHeap {
30
31 static class GenericSGOIDHeapMemento extends GenericHeapMemento {
32 IntTable.Snapshot<AllocationContext> ctxSnap;
33
34 GenericSGOIDHeapMemento (GenericSGOIDHeap heap) {
35 super(heap);
36
37 ctxSnap = heap.allocCounts.getSnapshot();
38 }
39
40 @Override
41 public Heap restore(Heap inSitu) {
42 super.restore( inSitu);
43
44 GenericSGOIDHeap heap = (GenericSGOIDHeap) inSitu;
45 heap.allocCounts.restore(ctxSnap);
46
47 return heap;
48 }
49 }
50
51 // these are search global
52 protected int nextSgoid;
53 protected IntTable<Allocation> sgoids;
54
55 // this is state managed
56 // NOTE - this has to be included in the mementos of concrete Heap implementations
57 protected IntTable<AllocationContext> allocCounts;
58
59 protected GenericSGOIDHeap (Config config, KernelState ks){
60 super(config, ks);
61
62 // static inits
63 initAllocationContext(config);
64 sgoids = new IntTable<Allocation>();
65 nextSgoid = 0;
66
67 allocCounts = new IntTable<AllocationContext>();
68 }
69
70
71 //--- to be overridden by subclasses that use different AllocationContext implementations
72
73 protected void initAllocationContext(Config config) {
74 HashedAllocationContext.init(config);
75 //PreciseAllocationContext.init(config);
76 }
77
78 // these are always called directly from the allocation primitive, i.e. the allocating site is at a fixed
79 // stack offset (callers caller)
80 @Override
81 protected AllocationContext getSUTAllocationContext (ClassInfo ci, ThreadInfo ti) {
82 return HashedAllocationContext.getSUTAllocationContext(ci, ti);
83 //return PreciseAllocationContext.getSUTAllocationContext(ci, ti);
84 }
85 @Override
86 protected AllocationContext getSystemAllocationContext (ClassInfo ci, ThreadInfo ti, int anchor) {
87 return HashedAllocationContext.getSystemAllocationContext(ci, ti, anchor);
88 //return PreciseAllocationContext.getSystemAllocationContext(ci, ti, anchor);
89 }
90
91
92 @Override
93 protected int getNewElementInfoIndex (AllocationContext ctx) {
94 int idx;
95 int cnt;
96
97 IntTable.Entry<AllocationContext> cntEntry = allocCounts.getInc(ctx);
98 cnt = cntEntry.val;
99
100 Allocation alloc = new Allocation(ctx, cnt);
101
102 IntTable.Entry<Allocation> sgoidEntry = sgoids.get(alloc);
103 if (sgoidEntry != null) { // we already had this one
104 idx = sgoidEntry.val;
105
106 } else { // new entry
107 idx = ++nextSgoid;
108 sgoids.put(alloc, idx);
109 }
110
111 // sanity check - we do this here (and not in our super class) since we know how elements are stored
112 // assert get(idx) == null;
113
114 return idx;
115 }
116
117 }