The Gateway to Computer Science Excellence
First time here? Checkout the FAQ!
x
+20 votes
1.1k views

In a C program, an array is declared as $\text{float} \ A[2048]$. Each array element is $4 \ \text{Bytes}$ in size, and the starting address of the array is $0x00000000$. This program is run on a computer that has a direct mapped data cache of size $8  \ \text{Kbytes}$, with block (line) size of $16 \ \text{Bytes}$.

  1. Which elements of the array conflict with element $A[0]$ in the data cache? Justify your answer briefly.
  2. If the program accesses the elements of this array one by one in reverse order i.e., starting with the last element and ending with the first element,  how many data cache misses would occur? Justify your answer briefly. Assume that the data cache is initially empty and that no other data or instruction accesses are to be considered.
asked in CO & Architecture by Veteran (59.7k points)
edited by | 1.1k views
+1

Suppose the question mentioned array having 4096 elements.Then the  2049th element would conflict $A[0]$ right?

0
Question say each element is access one by one means there . will be 2048 miss instead of 512.Now if u consider block by blck access it should be 512. Correct me if I am wrong.
+1
When we fetch element from main memory into the cache we always do that in blocks by considering the spatial locality of reference,so there will be 512 miss.
0
@Hitesh Yes if array is having 4096 elements then 2049th element will conflict with the  A[0] as 2049%2049=0.
0

@

Hitesh Junior

there will not be a single element that will conflict complete block of elements will conflict with that that is why in question part a elements is written

1 Answer

+29 votes
Best answer
  1. Data cache size $= 8 \ KB.$

    Block line size $= 16 \ B.$

    Since each array element occupies $4 \ B,$ four consecutive array elements occupy a block line (elements are aligned as starting address is $0$ )

    Number of cache blocks $=\dfrac{8 \ KB}{16 \ B}= 512.$
    Number of cache blocks needed for the array $=\dfrac{2048}{4}=512.$
    So, all the array elements has its own cache block and there is no collision.

    We can also explain this with respect to array address.
    Starting address is $\text{0x00000000} = 0_b0000\ldots0 \text{(32 0's)}.$
    Ending address is $\text{0x00001FFF} = 0_b0000\ldots 0111111111111 (4\times 2048
    = 8192 \text{ locations)}$.

    Here, the last $4\text{ bits}$ are used as OFFSET bits and the next $9$ bits are used as SET bits. So, since the ending address is not extending beyond these $9\text{ bits},$ all cache accesses are to diff sets.
     
  2. If the last element is accessed first, its cache block is fetched. (which should contain the previous $3$ elements of the array also since each cache block hold $4$ elements of array and $2048$ is and exact multiple of $4$ ). Thus, for every $4$ accesses, we will have a cache miss $\Rightarrow$ for $2048$ accesses we will have $512$ cache misses. (This would be same even if we access array in forward order).
answered by Veteran (368k points)
edited by
+1
Ending address is 0x00001000 ?​
0
corrected :)
0

part (a) -  although we have 512 cache blocks to store the array (4 contiguous elements in 1 cache block )
but since it is DIRECT MAPPED cache so we will apply { K mod c = i  ; where K is main memory block no  , c is no. of cache blocks , i is cache block no.} then there will be so many locations which will be mapped to same cache block line and hence misses will occur as a result of which A[0] data will get conflict........plz correct if i am wrong...!!

0
For each block mapping block will be different try this.
+1
@Arjun sir, It might be a silly doubt but still please help... Isn't the whole array being stored in the 8KB cache itself? If yes then there shouldn't be any miss at all, isn't it?
0
same doubt
+1
The cache initially is empty so to fetch the array elements misses will occur.

for ( int i = 0; i < 2048; i++)

      printf("%d ",arr[ i ]);

So to loop over the whole array once compulsory misses will occur. But if again I loop over the array then there would be 0 misses since the whole array can get fit perfectly in the cache.
0

If the last element is accessed first, its cache block is fetched. (which should
contain the previous 33 elements of the array also since each cache block
hold 44 elements of array and 2048 is and exact multiple of 44 ). Thus,
for every 44 accesses, we will have a cache miss ⇒⇒ for 2048
accesses we will have 512 cache misses. (This would be same even if we
access array in forward order).

@Tuhin Dutta Iam not able to relate this with the above explanation given by arjun Sir. please help  

Related questions



Quick search syntax
tags tag:apple
author user:martin
title title:apple
content content:apple
exclude -tag:apple
force match +apple
views views:100
score score:10
answers answers:2
is accepted isaccepted:true
is closed isclosed:true

44,250 questions
49,744 answers
164,042 comments
65,842 users