PersistentTable.cc (10301:44839e8febbd) PersistentTable.cc (11025:4872dbdea907)
1/*
2 * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;

--- 33 unchanged lines hidden (view full) ---

42{
43}
44
45PersistentTable::~PersistentTable()
46{
47}
48
49void
1/*
2 * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;

--- 33 unchanged lines hidden (view full) ---

42{
43}
44
45PersistentTable::~PersistentTable()
46{
47}
48
49void
50PersistentTable::persistentRequestLock(const Address& address,
50PersistentTable::persistentRequestLock(Addr address,
51 MachineID locker,
52 AccessType type)
53{
54#if 0
55 if (locker == m_chip_ptr->getID())
56 cout << "Chip " << m_chip_ptr->getID() << ": " << llocker
57 << " requesting lock for " << address << endl;
58
59 MachineID locker = (MachineID) persistent_randomize[llocker];
60#endif
61
51 MachineID locker,
52 AccessType type)
53{
54#if 0
55 if (locker == m_chip_ptr->getID())
56 cout << "Chip " << m_chip_ptr->getID() << ": " << llocker
57 << " requesting lock for " << address << endl;
58
59 MachineID locker = (MachineID) persistent_randomize[llocker];
60#endif
61
62 assert(address == line_address(address));
62 assert(address == makeLineAddress(address));
63
64 static const PersistentTableEntry dflt;
65 pair<AddressMap::iterator, bool> r =
66 m_map.insert(AddressMap::value_type(address, dflt));
67 bool present = !r.second;
68 AddressMap::iterator i = r.first;
69 PersistentTableEntry &entry = i->second;
70

--- 6 unchanged lines hidden (view full) ---

77 if (type == AccessType_Write)
78 entry.m_request_to_write.add(locker);
79
80 if (present)
81 assert(entry.m_marked.isSubset(entry.m_starving));
82}
83
84void
63
64 static const PersistentTableEntry dflt;
65 pair<AddressMap::iterator, bool> r =
66 m_map.insert(AddressMap::value_type(address, dflt));
67 bool present = !r.second;
68 AddressMap::iterator i = r.first;
69 PersistentTableEntry &entry = i->second;
70

--- 6 unchanged lines hidden (view full) ---

77 if (type == AccessType_Write)
78 entry.m_request_to_write.add(locker);
79
80 if (present)
81 assert(entry.m_marked.isSubset(entry.m_starving));
82}
83
84void
85PersistentTable::persistentRequestUnlock(const Address& address,
85PersistentTable::persistentRequestUnlock(Addr address,
86 MachineID unlocker)
87{
88#if 0
89 if (unlocker == m_chip_ptr->getID())
90 cout << "Chip " << m_chip_ptr->getID() << ": " << uunlocker
91 << " requesting unlock for " << address << endl;
92
93 MachineID unlocker = (MachineID) persistent_randomize[uunlocker];
94#endif
95
86 MachineID unlocker)
87{
88#if 0
89 if (unlocker == m_chip_ptr->getID())
90 cout << "Chip " << m_chip_ptr->getID() << ": " << uunlocker
91 << " requesting unlock for " << address << endl;
92
93 MachineID unlocker = (MachineID) persistent_randomize[uunlocker];
94#endif
95
96 assert(address == line_address(address));
96 assert(address == makeLineAddress(address));
97 assert(m_map.count(address));
98 PersistentTableEntry& entry = m_map[address];
99
100 //
101 // Make sure we're in the locked set
102 //
103 assert(entry.m_starving.isElement(unlocker));
104 assert(entry.m_marked.isSubset(entry.m_starving));

--- 5 unchanged lines hidden (view full) ---

110 // Deallocate if empty
111 if (entry.m_starving.isEmpty()) {
112 assert(entry.m_marked.isEmpty());
113 m_map.erase(address);
114 }
115}
116
117bool
97 assert(m_map.count(address));
98 PersistentTableEntry& entry = m_map[address];
99
100 //
101 // Make sure we're in the locked set
102 //
103 assert(entry.m_starving.isElement(unlocker));
104 assert(entry.m_marked.isSubset(entry.m_starving));

--- 5 unchanged lines hidden (view full) ---

110 // Deallocate if empty
111 if (entry.m_starving.isEmpty()) {
112 assert(entry.m_marked.isEmpty());
113 m_map.erase(address);
114 }
115}
116
117bool
118PersistentTable::okToIssueStarving(const Address& address,
118PersistentTable::okToIssueStarving(Addr address,
119 MachineID machId) const
120{
119 MachineID machId) const
120{
121 assert(address == line_address(address));
121 assert(address == makeLineAddress(address));
122
123 AddressMap::const_iterator i = m_map.find(address);
124 if (i == m_map.end()) {
125 // No entry present
126 return true;
127 }
128
129 const PersistentTableEntry &entry = i->second;
130
131 if (entry.m_starving.isElement(machId)) {
132 // We can't issue another lockdown until are previous unlock
133 // has occurred
134 return false;
135 }
136
137 return entry.m_marked.isEmpty();
138}
139
140MachineID
122
123 AddressMap::const_iterator i = m_map.find(address);
124 if (i == m_map.end()) {
125 // No entry present
126 return true;
127 }
128
129 const PersistentTableEntry &entry = i->second;
130
131 if (entry.m_starving.isElement(machId)) {
132 // We can't issue another lockdown until are previous unlock
133 // has occurred
134 return false;
135 }
136
137 return entry.m_marked.isEmpty();
138}
139
140MachineID
141PersistentTable::findSmallest(const Address& address) const
141PersistentTable::findSmallest(Addr address) const
142{
142{
143 assert(address == line_address(address));
143 assert(address == makeLineAddress(address));
144 AddressMap::const_iterator i = m_map.find(address);
145 assert(i != m_map.end());
146 const PersistentTableEntry& entry = i->second;
147 return entry.m_starving.smallestElement();
148}
149
150AccessType
144 AddressMap::const_iterator i = m_map.find(address);
145 assert(i != m_map.end());
146 const PersistentTableEntry& entry = i->second;
147 return entry.m_starving.smallestElement();
148}
149
150AccessType
151PersistentTable::typeOfSmallest(const Address& address) const
151PersistentTable::typeOfSmallest(Addr address) const
152{
152{
153 assert(address == line_address(address));
153 assert(address == makeLineAddress(address));
154 AddressMap::const_iterator i = m_map.find(address);
155 assert(i != m_map.end());
156 const PersistentTableEntry& entry = i->second;
157 if (entry.m_request_to_write.
158 isElement(entry.m_starving.smallestElement())) {
159 return AccessType_Write;
160 } else {
161 return AccessType_Read;
162 }
163}
164
165void
154 AddressMap::const_iterator i = m_map.find(address);
155 assert(i != m_map.end());
156 const PersistentTableEntry& entry = i->second;
157 if (entry.m_request_to_write.
158 isElement(entry.m_starving.smallestElement())) {
159 return AccessType_Write;
160 } else {
161 return AccessType_Read;
162 }
163}
164
165void
166PersistentTable::markEntries(const Address& address)
166PersistentTable::markEntries(Addr address)
167{
167{
168 assert(address == line_address(address));
168 assert(address == makeLineAddress(address));
169 AddressMap::iterator i = m_map.find(address);
170 if (i == m_map.end())
171 return;
172
173 PersistentTableEntry& entry = i->second;
174
175 // None should be marked
176 assert(entry.m_marked.isEmpty());
177
178 // Mark all the nodes currently in the table
179 entry.m_marked = entry.m_starving;
180}
181
182bool
169 AddressMap::iterator i = m_map.find(address);
170 if (i == m_map.end())
171 return;
172
173 PersistentTableEntry& entry = i->second;
174
175 // None should be marked
176 assert(entry.m_marked.isEmpty());
177
178 // Mark all the nodes currently in the table
179 entry.m_marked = entry.m_starving;
180}
181
182bool
183PersistentTable::isLocked(const Address& address) const
183PersistentTable::isLocked(Addr address) const
184{
184{
185 assert(address == line_address(address));
185 assert(address == makeLineAddress(address));
186
187 // If an entry is present, it must be locked
188 return m_map.count(address) > 0;
189}
190
191int
186
187 // If an entry is present, it must be locked
188 return m_map.count(address) > 0;
189}
190
191int
192PersistentTable::countStarvingForAddress(const Address& address) const
192PersistentTable::countStarvingForAddress(Addr address) const
193{
193{
194 assert(address == line_address(address));
194 assert(address == makeLineAddress(address));
195 AddressMap::const_iterator i = m_map.find(address);
196 if (i == m_map.end())
197 return 0;
198
199 const PersistentTableEntry& entry = i->second;
200 return entry.m_starving.count();
201}
202
203int
195 AddressMap::const_iterator i = m_map.find(address);
196 if (i == m_map.end())
197 return 0;
198
199 const PersistentTableEntry& entry = i->second;
200 return entry.m_starving.count();
201}
202
203int
204PersistentTable::countReadStarvingForAddress(const Address& address) const
204PersistentTable::countReadStarvingForAddress(Addr address) const
205{
205{
206 assert(address == line_address(address));
206 assert(address == makeLineAddress(address));
207 AddressMap::const_iterator i = m_map.find(address);
208 if (i == m_map.end())
209 return 0;
210
211 const PersistentTableEntry& entry = i->second;
212 return entry.m_starving.count() - entry.m_request_to_write.count();
213}
214
215void
216PersistentTable::print(ostream& out) const
217{
218}
219
207 AddressMap::const_iterator i = m_map.find(address);
208 if (i == m_map.end())
209 return 0;
210
211 const PersistentTableEntry& entry = i->second;
212 return entry.m_starving.count() - entry.m_request_to_write.count();
213}
214
215void
216PersistentTable::print(ostream& out) const
217{
218}
219