Cache Memory Caches depend on the locality principle – if you access memory locations near to each other, then you will get better performance because the cache will pull in a bunch of nearby locations every time you access main memory. Assume that multi-dimensional arrays in C are stored in “row major order”, that is, the elements in each row are stored together Example: int test[3][5] = { {1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}, {11, 12, 13, 14, 15} } Would be laid out in memory like: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Which of these two programs fragments (a or b) should have better cache performance? You need only answer “a” or “b” – no explanation needed. // begin fragment a int big[100,1000]; for (i=0, i<100, i++) { for (j=0, j<999, j++) { big[i,j] += big[i,j+1]; } } // end fragment a // begin fragment b int big[100,1000]; for (j=0, j<999, j++) { for (i=0, i<100, i++) { big[i,j] += big[i,j+1]; } } // end fragment b
Cache Memory
Caches depend on the locality principle – if you access memory locations near to each other,
then you will get better performance because the cache will pull in a bunch of nearby locations
every time you access main memory. Assume that multi-dimensional arrays in C are stored in “row major order”, that is, the elements in each row are stored together
Example:
int test[3][5] = {
{1, 2, 3, 4, 5},
{6, 7, 8, 9, 10},
{11, 12, 13, 14, 15}
}
Would be laid out in memory like:
|
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
Which of these two programs fragments (a or b) should have better cache performance?
You need only answer “a” or “b” – no explanation needed.
// begin fragment a
int big[100,1000];
for (i=0, i<100, i++) {
for (j=0, j<999, j++) {
big[i,j] += big[i,j+1];
}
}
// end fragment a
// begin fragment b
int big[100,1000];
for (j=0, j<999, j++) {
for (i=0, i<100, i++) {
big[i,j] += big[i,j+1];
}
}
// end fragment b
![Caches depend on the locality principle – if you access memory locations near to each other,
then you will get better performance because the cache will pull in a bunch of nearby locations
every time you access main memory. Assume that multi-dimensional arrays in C are stored in
"row major order", that is, the elements in each row are stored together
Example:
int test[3][5]
{
{1, 2, 3, 4, 5},
{ 6, 7, 8, 9, 10},
{11, 12, 13, 14, 15}
}
Would be laid out in memory like:
中
1
4
6.
7
10
11
12
13
14
15
Which of these two programs fragments (a or b) should have better cache performance?
You need only answer "a" or “b" – no explanation needed.
-
// begin fragment a
int bigl100,1000];
for (i=0, i<100, i++) {
for (j=0, j<999, it {
big[inl += big[i,j+1];
}
// end fragment a
// begin fragment b
int big[100,1000];
for (j=0, j<999, itt) {
for (i=0, i<100, į++) {
big [iil += big[i,j+1];
}
}
// end fragment b](/v2/_next/image?url=https%3A%2F%2Fcontent.bartleby.com%2Fqna-images%2Fquestion%2F8cb58778-70ba-4f7e-90ce-7267bd79a013%2F61b09746-d59e-4fad-ae71-e11c40a6d612%2Ft2o0qqa_processed.png&w=3840&q=75)
Trending now
This is a popular solution!
Step by step
Solved in 3 steps
