Programming for Hardware/Software Systems Study Guide: Heap Management

Transcription

Programming for Hardware/Software Systems Study Guide: Heap Management
ECE 2035
Study Guide: Part 5
Version 1.0
Programming for
Hardware/Software Systems
Study Guide: Heap Management
This study guide provides example problems on material from the class outline. It
is valuable in helping you test your understanding of concepts from lecture. Many
of these problems are from old exams; so they also provide good exam preparation.
Solutions are provided to verify your answers.
If any errors are detected, please send mail to [email protected] so
future versions can be corrected.
Good Luck!
Version 1.0
November 2012
Copyright © 2012
1
ECE 2035
Study Guide: Part 5
Version 1.0
Problem HM-1 (2 parts)
Hash Tables
Consider an open hash table composed of a four-bucket table, with each bucket containing a
variable length list. Each list entry has three slots <key, value, next> corresponding to the three
word groupings in the entries section. The hash function is key mod four. Inserted entries
are appended to the end of a bucket list. Deallocated entries are maintained on a LIFO free list.
When the free list is empty, new entry objects are allocated from heap memory. Accesses are
listed as <op, key, [value]>. Simulate the access list below and draw the ending state. Assume
the hash table is initially empty, the heap pointer is initially 5016 and the free pointer is initially
0.
Part A:
5016
Heap
Pointer
Free
List
0000
Buckets
5000
5004
5008
5012
Entries
5016
5040
5064
5088
5020
5044
5068
5092
5024
5048
5072
5096
5028
5052
5076
5100
5032
5056
5080
5104
5036
5060
5084
5108
#
1
2
3
4
op
insert
insert
insert
insert
key
1006
1000
1004
1006
Hash Table Access Trace
value
#
op
111
5
insert
222
6
remove
333
7
remove
444
8
insert
2
key
1002
1000
1002
1003
value
555
n/a
n/a
666
ECE 2035
Study Guide: Part 5
Version 1.0
Part B:
5016
Heap
Pointer
Free
List
0000
Buckets
5000
5004
5008
5012
Entries
5016
5040
5064
5088
5020
5044
5068
5092
5024
5048
5072
5096
5028
5052
5076
5100
5032
5056
5080
5104
5036
5060
5084
5108
#
1
2
3
4
op
insert
insert
insert
insert
key
1001
1005
1003
1007
Hash Table Access Trace
value
#
op
111
5
remove
222
6
remove
333
7
insert
444
8
insert
3
key
1001
1007
1003
1006
value
n/a
n/a
555
666
ECE 2035
Study Guide: Part 5
Problem HM-2 (6 parts)
Version 1.0
Heap Management
Below is a snapshot of heap storage. Values that are pointers are denoted with a “$”. The heap pointer is
$6172 and the free pointer is $6032. The heap has been allocated contiguously beginning at $6000,
with no gaps between objects.
addr
value
addr
value
addr
value
addr
value
addr
value
addr
value
6000
12 6032 $6100 6064 $6148 6096
12 6128
12 6160
0
6004
48 6036
8 6068
4 6100 $6080 6132
4 6164
4
6008
4 6040
24 6072
12 6104
16 6136
4 6168
0
6012
16 6044
4 6076
8 6108
4 $6140
0 6172
0
6016
8 6048
8 6080 $6052 6112
8 6144
16 6176
0
6020
8 6052 $6140 6084
0 6116
8 6148
0 6180
0
6024
24 6056
8 6088
4 6120
16 6152
8 6184
0
6028
4 6060
12 6092 $6052 6124
8 6156
12 6188
0
Part A Assuming the heap has been allocated contiguously beginning at 6000, with no gaps
between objects, circle all object size words in the map above.
Part B List the address of the first data word in each object in the free list in order, starting
with the head of the free list.
Free List:
Part C Based on the free list created in part B, if an object of size 7 bytes is allocated, what
address will be returned using a first-fit allocation strategy?
Address:
Part D Based on the free list created in part B, if an object of size 7 bytes is allocated, what
address will be returned using a best-fit allocation strategy?
Address:
Part E Based on the free list created in part B, if an object of size 15 bytes is allocated, what
address will be returned using a best-fit allocation strategy?
Address:
Part F If the next instruction is free($6064), what memory changes will result? What will the
free pointer become?
memory
changes
free ptr
4
ECE 2035
Study Guide: Part 5
Problem HM-3 (2 parts)
#define
#define
#define
#define
#define
INITNUMBUCKETS
LINKBLOCKSIZE
RESIZERATIO
NOMATCH
DEBUG
typedef struct
int
int
struct Link
} Link;
Link {
Key;
Value;
*Next;
typedef struct
Link
int
Link
int
} HashTable;
{
**Buckets;
NumBuckets;
*FreeLinks;
Size;
Version 1.0
Hash Table Implementation
5
16
1
-1
0
void Insert(HashTable *HT, int Key, int Value) {
Link
*FoundLink;
}
FoundLink = Find_Key(HT, Key);
if (FoundLink != NULL)
FoundLink->Value = Value;
else {
if (HT->FreeLinks == NULL)
HT->FreeLinks = Make_New_Links();
FoundLink = HT->FreeLinks;
HT->FreeLinks = HT->FreeLinks->Next;
FoundLink->Key = Key;
FoundLink->Value = Value;
FoundLink->Next = HT->Buckets[Hash(HT, Key)];
HT->Buckets[Hash(HT, Key)] = FoundLink;
HT->Size += 1;
if (HT->Size > HT->NumBuckets * RESIZERATIO)
Resize_Hash_Table(HT);
}
Part A: Complete the C function Find_Key that searches the hash table for an entry
corresponding to a specified key. It should return a pointer to the matching Link entry if the
key is found or return NULL if the key is not found in the hash table.
Link *Find_Key(HashTable *HT, int Key) {
Link
*ThisLink;
int
Index;
int
Hash(HashTable *HT, int Key);
}
return ThisLink;
Part B: The following questions are related to the hash table implementation listed above.
When Insert is called more than
once with the same key, what occurs?
Where is a new entry link placed on
the bucket list?
What is the range of possible values
for average bucket list length?
Describe the type of Buckets in
HashTable (in 10 words or less).
What is the size (in bytes) of
HashTable?
What is the size (in bytes) of the
initial Buckets array?
5
ECE 2035
Study Guide: Part 5
Version 1.0
Problem HM-4 (4 parts)
Heap Manager Implementation
Consider the following fragment from a HeapManager implementation. Note that $2 is the freed
object pointer and $3 is the free list.
Label1:
beq
add
lw
lw
slt
bne
sw
$3,
$6,
$4,
$5,
$5,
$5,
$3,
$0, Label1
$3, $0
-4($2)
-4($3)
$5, $4
$0, Label3
0($2)
#
#
#
#
#
#
#
I01
I02
I03
I04
I05
I06
I07
Part A: Using abstract terms, define what is being compared in I05(slt). Don't simply
transliterate the MIPS instructions (e.g., don't say “reg 2 is added to reg 3”).
Part B: Describe the two cases where I07(sw) is executed. Be specific.
1.
2.
Part C: Consider the three pointers below. Assume their initialized value is the address of an
appropriate address in memory. For each statement below, list the resultant value. If the value is
undecidable, list “error”.
char
void
void
Heap + 1
*Heap = 5000;
*Object = 6000;
**Free = 7000;
Object + 1
mem[5000] = 5500
mem[6000] = 6500
mem[7000] = 7500
Free + 1
Part D: Concisely define the following terms?
void pointer:
null pointer:
6
((int *) *Free) + 1
ECE 2035
Study Guide: Part 5
Version 1.0
Problem HM-5 (3 parts)
Heap Management
Below is a snapshot of heap storage. The heap has been allocated contiguously beginning at address 6000,
with no gaps between objects using a heap manager implemented in C.
addr
value
addr
value
addr
value
addr
value
addr
value
addr value
6000
16
6032
12
6064
0
6096
16
6128
12
6160
0
6004
33
6036
28
6068
4
6100
0
6132
6036
6164
0
6008
6072
6040
24
6072
6100
6104
16
6136
2525
6168
0
6012
16
6044
60
6076
8
6108
5
6140
0
6172
0
6016
6080
6048
16
6080
6080
6112
6004
6144
20
6176
0
6020
8
6052
6
6084
6004
6116
8
6148
6036
6180
0
6024
6120
6056
6100
6088
4
6120
6100
6152
8
6184
0
6028
52
6060
0
6092
6024
6124
24
6156
26
6188
0
Below is a portion of the heap manager:
L-1
L-2
L-3
L-4
L-5
L-6
L-7
L-8
L-9
L-10
L-11
L-12
L-13
L-14
L-15
L-16
L-17
char
char
void
Heap[HEAPSIZE];
*HeapPtr = Heap;
**FreePtr = NULL;
void Free(void *ObjectPtr) {
int
ObjectSize;
void
**ThisPtr = FreePtr;
void
**LastPtr = (void **) &FreePtr;
ObjectSize = *(-1 + (int *) ObjectPtr);
while (ThisPtr != NULL && ObjectSize > *((int *) ThisPtr - 1)) {
LastPtr = ThisPtr;
ThisPtr = (void **) *ThisPtr;
}
* (void **) ObjectPtr = ThisPtr;
*LastPtr = ObjectPtr;
}
Assume HeapPtr = 6168 and FreePtr = 6092 and FreePtr is located at address 5064.
Part A: Circle all object size words in the snapshot above.
Part B: List the base addresses of the heap
objects that are on the free list in the order
they appear on the free list.
Part C: Suppose the following function call is made: Free(p), where p=6132. Given the snapshot of
heap above, what is the value of the following at each of the indicated locations in the code?
ThisPtr
LastPtr
at L-9
at L-17
7
*ObjectPtr
ECE 2035
Study Guide: Part 5
Version 1.0
Problem HM-6 (5 parts)
Garbage Collection
Below is a snapshot of heap storage. Values that are pointers are denoted with a “$”. The heap
pointer is $6168. The heap has been allocated contiguously beginning at $6000, with no gaps
between objects.
addr
6000
6004
6008
6012
6016
6020
6024
6028
value
16
33
$6072
16
$6080
8
25
52
addr
6032
6036
6040
6044
6048
6052
6056
6060
value
12
28
24
60
16
6
$6100
0
addr
6064
6068
6072
6076
6080
6084
6088
6092
value
0
4
$6100
8
$6080
$6004
4
50
addr
6096
6100
6104
6108
6112
6116
6120
6124
value
16
$6036
16
5
$6004
8
32
24
addr
6128
6132
6136
6140
6144
6148
6152
6156
value
12
8000
2525
0
20
$6036
8
26
addr
6160
6164
6168
6172
6176
6180
6184
6188
value
0
0
0
0
0
0
0
0
Part A: Suppose the stack holds a local variable whose value is the memory address $6052 and
register $3 holds the address $6148. No other registers or static variables currently hold heap
memory addresses. List the addresses of all objects in the heap that are not garbage.
Addresses of Non-Garbage Objects:
Part B: Create a free list by scanning the memory for garbage, starting at address $6000 and
pushing each reclaimed object on the front of the free list. List the addresses of the objects (in
order) on the free list at the end of the scan.
Free List:
Part C: Based on the free list created in part B, if an object of size 13 bytes is allocated, what
address will be returned using a best-fit allocation strategy?
Address:
Part D: Based on the free list created in part B, if an object of size 9 bytes is allocated, what
address will be returned using a best-fit allocation strategy?
Address:
Part E: If the local variable whose value is the address $6052 is popped from the stack, which
addresses will be reclaimed by each of the following strategies? If none, write “none.” (You do
not have to list addresses already on the free list from part B.)
Reference Counting:
Mark and Sweep:
Old-New Space (copying):
8
ECE 2035
Study Guide: Part 5
Version 1.0
Problem HM-7 (5 parts)
Garbage Collection
Below is a snapshot of heap storage. Values that are pointers are denoted with a “$”. The heap pointer is
$6160. The heap has been allocated contiguously beginning at $6000, with no gaps between objects.
addr value
addr
value
addr
value
addr
value
addr
value
addr value
6000
8 6032
12 6064
8 6096
4 6128
6024 6160
0
6004
6132 6036
28 6068
$6004 6100
$6036 6132
12 6164
0
6008 $6092 6040 $6108 6072
20 6104
16 6136
4 6168
0
6012
16 6044
6024 6076
8 6108
6076 6140
16 6172
0
6016
6180 6048
12 6080
6004 6112
152 6144
4 6176
0
6020
8 6052
6 6084
$6016 6116
8 6148
8 6180
0
6024
25 6056
6080 6088
12 6120
$6004 6152
6100 6184
0
6028 $6128 6060
8 6092
6040 6124
4 6156 $6036 6188
0
Part A Suppose the stack holds a local variable whose value is the memory address $6068 and register
$4 holds the address $6152. No other registers or static variables currently hold heap memory addresses.
List the addresses of all objects in the heap that are not garbage.
Addresses of Non-Garbage Objects:
Part B Create a sorted (by size) free list by scanning the memory for garbage, starting at address $6000
and inserting each garbage object into the free list in increasing size order. List the base address of each
object (not the address of the header) on the free list (in order) at the end of the scan.
Free List:
Part C Based on the free list created in part B, if an object of size 5 bytes is allocated, what address will
be returned using a best-fit allocation strategy? How many bytes of slack (if any) will result? What is the
value of the heap pointer after the object is allocated?
Address:
Slack:
bytes
Heap Pointer:
Part D Based on the free list created in part B, if an object of size 19 bytes is allocated, what address will
be returned using a best-fit allocation strategy? How many bytes of slack (if any) will result? What is the
value of the heap pointer after the object is allocated?
Address:
Slack:
bytes
Heap Pointer:
Part E If the local variable whose value is the address $6068 is popped from the stack, which addresses
will be reclaimed by each of the following strategies? If none, write “none.” (You do not have to list
addresses already on the free list from part B.)
Reference Counting:
Mark and Sweep:
Old-New Space (copying):
9
ECE 2035
Study Guide: Part 5
Version 1.0
Problem HM-8 (3 parts)
Associative Sets and Search
Part A Consider a hash table that uses 21 buckets, each containing an unsorted LIFO list of
items. Inserted entries are appended to the end of the bucket list. Suppose the hash table contains
210 entries total and the entries are evenly distributed across the hash table buckets. Assume
that computing the hash function takes an average of two operations and comparing two strings
takes an average of twenty operations. Ignore effects of spatial and temporal reference locality.
Suppose that 80% of keys looked up are found in the hash table and 20% are not found. How
many of these operations would be required for the average lookup in the hash table described
above? (show work)
operations
Part B Suppose the hash table automatically resizes (with the same 210 entries and found key
probabilities) so that the average access time becomes 82 operations. How many hash table
buckets are being used? (show work)
new number of buckets:
Part C Implement a function findpos that returns the earliest position of the character x in a
character string. If x does not appear in the character string, return ­1. For example:
char sample[] = “Happy Birthday”;
findpos('p', sample); /* returns 2 */
findpos('m', sample); /* returns ­1 */
findpos('H', sample); /* returns 0 */
int findpos(char x, char *str) {
}
10
ECE 2035
Study Guide: Part 5
Version 1.0
Problem HM-9 (3 parts)
Associative Sets
Part A Consider a hash table that uses 15 buckets, each containing an unsorted LIFO list of
items. Suppose the hash table contains 600 entries total and the entries are evenly distributed
across the hash table buckets. Assume that computing the hash function takes an average of
three operations and comparing two keys takes an average of ten operations. Ignore effects of
spatial and temporal reference locality. Suppose that 80% of keys looked up are found in the
hash table and 20% are not found. How many of these operations would be required for the
average lookup in the hash table described above? (show work)
operations
Part B For the hash table in Part A, recompute the cost assuming that the bucket lists are sorted
in order of ascending keys. How many of these operations would be required for the average
lookup in the hash table described above? (show work)
operations
Part C Explain the difference between malloc() and calloc().
malloc
calloc
Part D Briefly describe the unfortunate outcome if a pointer to a stack-allocated object is
passed to the function free().
11