Computer Science Engineering (CSE) Exam > Computer Science Engineering (CSE) Questions > In a C program, an array is declared as float...
Start Learning for Free
In a C program, an array is declared as float A[2048]. Each array element is 4 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 Kbytes, with block (line) size of 16 Bytes.
a. Which elements of the array conflict with element A[0] in the data cache? Justify your answer briefly.
b. 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.
a. Which elements of the array conflict with element A[0] in the data cache? Justify your answer briefly.
b. 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.
Correct answer is '(a)'. Can you explain this answer?
| FREE This question is part of | Download PDF Attempt this Test |
Verified Answer
In a C program, an array is declared as float A[2048]. Each array elem...
(a)
Data cache size = 8KB.
Block line size = 16B.
Since each array element occupies 4B, four consecutive array elements occupy a block line (elements are aligned as
starting address is 0)
Number of cache blocks = 8KB/16B = 512. Number of cache blocks needed for the array = 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 0x00000000 = 0b0000..0 (32 0's). Ending
address is 0x00001FFF = 0b0000..0111111111111 (4*2048 = 8192 location).
Here, the last 4 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 bits, all cache accesses are to diff sets.
(b) 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 => for 2048 accesses we will have 512 cache misses. (This would be same even if we
access array in forward order).
Data cache size = 8KB.
Block line size = 16B.
Since each array element occupies 4B, four consecutive array elements occupy a block line (elements are aligned as
starting address is 0)
Number of cache blocks = 8KB/16B = 512. Number of cache blocks needed for the array = 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 0x00000000 = 0b0000..0 (32 0's). Ending
address is 0x00001FFF = 0b0000..0111111111111 (4*2048 = 8192 location).
Here, the last 4 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 bits, all cache accesses are to diff sets.
(b) 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 => for 2048 accesses we will have 512 cache misses. (This would be same even if we
access array in forward order).
Most Upvoted Answer
In a C program, an array is declared as float A[2048]. Each array elem...
(a)
Data cache size = 8KB.
Block line size = 16B.
Since each array element occupies 4B, four consecutive array elements occupy a block line (elements are aligned as
starting address is 0)
Number of cache blocks = 8KB/16B = 512. Number of cache blocks needed for the array = 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 0x00000000 = 0b0000..0 (32 0's). Ending
address is 0x00001FFF = 0b0000..0111111111111 (4*2048 = 8192 location).
Here, the last 4 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 bits, all cache accesses are to diff sets.
(b) 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 => for 2048 accesses we will have 512 cache misses. (This would be same even if we
access array in forward order).
Data cache size = 8KB.
Block line size = 16B.
Since each array element occupies 4B, four consecutive array elements occupy a block line (elements are aligned as
starting address is 0)
Number of cache blocks = 8KB/16B = 512. Number of cache blocks needed for the array = 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 0x00000000 = 0b0000..0 (32 0's). Ending
address is 0x00001FFF = 0b0000..0111111111111 (4*2048 = 8192 location).
Here, the last 4 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 bits, all cache accesses are to diff sets.
(b) 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 => for 2048 accesses we will have 512 cache misses. (This would be same even if we
access array in forward order).
Free Test
FREE
| Start Free Test |
Community Answer
In a C program, an array is declared as float A[2048]. Each array elem...
Answer:
(a) Conflict Misses:
To determine which elements of the array conflict with element A[0] in the data cache, we need to consider the cache mapping scheme. In this case, the data cache is direct mapped, which means that each block (line) in the cache can hold only one memory block.
Block Size: The block size of the cache is 16 Bytes. Since each element of the array is 4 Bytes in size, each memory block can hold 4 elements.
Cache Size: The cache size is 8 Kbytes, which is equal to 8192 Bytes. We can calculate the number of cache blocks using the formula: cache size / block size = 8192 / 16 = 512 blocks.
Now, let's consider the memory addresses of the elements of the array. The starting address of the array is 0x00000000, and each element is 4 Bytes in size. Therefore, the memory address of A[0] is 0x00000000, the memory address of A[1] is 0x00000004, the memory address of A[2] is 0x00000008, and so on.
Since the cache is direct mapped, each memory block can be mapped to only one specific cache block. In this case, the memory address is divided into two parts: the tag and the index bits. The tag bits identify the memory block, and the index bits identify the cache block.
Since the memory address of A[0] is 0x00000000, the tag bits are 0x0000 and the index bits are 0x0. Therefore, A[0] will be mapped to cache block 0.
The cache block 0 can hold 4 elements of the array starting from A[0]. Therefore, the elements that conflict with A[0] in the data cache are A[4], A[8], A[12], and so on. These elements have the same index bits (0x0) as A[0] and will be mapped to the same cache block.
(b) Data Cache Misses:
If the program accesses the elements of the array in reverse order, starting with the last element and ending with the first element, the number of data cache misses can be calculated as follows:
Since the cache is initially empty, each element accessed will result in a cache miss until the cache is filled. The cache can hold 512 blocks, and each block can hold 4 elements. Therefore, the cache can hold a total of 512 * 4 = 2048 elements.
If the program accesses the elements of the array one by one in reverse order, a total of 2048 elements will be accessed. However, since the cache can only hold 2048 elements, all the elements will be present in the cache after the first access.
Therefore, only the first access to each element will result in a cache miss. Since there are 2048 elements in the array, there will be a total of 2048 cache misses.
In summary:
- The elements that conflict with A[0] in the data cache are A[4], A[8], A[12], and so on.
- If the program accesses the elements of the array one by one in reverse order,
(a) Conflict Misses:
To determine which elements of the array conflict with element A[0] in the data cache, we need to consider the cache mapping scheme. In this case, the data cache is direct mapped, which means that each block (line) in the cache can hold only one memory block.
Block Size: The block size of the cache is 16 Bytes. Since each element of the array is 4 Bytes in size, each memory block can hold 4 elements.
Cache Size: The cache size is 8 Kbytes, which is equal to 8192 Bytes. We can calculate the number of cache blocks using the formula: cache size / block size = 8192 / 16 = 512 blocks.
Now, let's consider the memory addresses of the elements of the array. The starting address of the array is 0x00000000, and each element is 4 Bytes in size. Therefore, the memory address of A[0] is 0x00000000, the memory address of A[1] is 0x00000004, the memory address of A[2] is 0x00000008, and so on.
Since the cache is direct mapped, each memory block can be mapped to only one specific cache block. In this case, the memory address is divided into two parts: the tag and the index bits. The tag bits identify the memory block, and the index bits identify the cache block.
Since the memory address of A[0] is 0x00000000, the tag bits are 0x0000 and the index bits are 0x0. Therefore, A[0] will be mapped to cache block 0.
The cache block 0 can hold 4 elements of the array starting from A[0]. Therefore, the elements that conflict with A[0] in the data cache are A[4], A[8], A[12], and so on. These elements have the same index bits (0x0) as A[0] and will be mapped to the same cache block.
(b) Data Cache Misses:
If the program accesses the elements of the array in reverse order, starting with the last element and ending with the first element, the number of data cache misses can be calculated as follows:
Since the cache is initially empty, each element accessed will result in a cache miss until the cache is filled. The cache can hold 512 blocks, and each block can hold 4 elements. Therefore, the cache can hold a total of 512 * 4 = 2048 elements.
If the program accesses the elements of the array one by one in reverse order, a total of 2048 elements will be accessed. However, since the cache can only hold 2048 elements, all the elements will be present in the cache after the first access.
Therefore, only the first access to each element will result in a cache miss. Since there are 2048 elements in the array, there will be a total of 2048 cache misses.
In summary:
- The elements that conflict with A[0] in the data cache are A[4], A[8], A[12], and so on.
- If the program accesses the elements of the array one by one in reverse order,
Attention Computer Science Engineering (CSE) Students!
To make sure you are not studying endlessly, EduRev has designed Computer Science Engineering (CSE) study material, with Structured Courses, Videos, & Test Series. Plus get personalized analysis, doubt solving and improvement plans to achieve a great score in Computer Science Engineering (CSE).
|
Explore Courses for Computer Science Engineering (CSE) exam
|
|
Similar Computer Science Engineering (CSE) Doubts
Top Courses for Computer Science Engineering (CSE)View all
In a C program, an array is declared as float A[2048]. Each array element is 4 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 Kbytes, with block (line) size of 16 Bytes.a. Which elements of the array conflict with element A[0] in the data cache? Justify your answer briefly.b. 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.Correct answer is '(a)'. Can you explain this answer?
Question Description
In a C program, an array is declared as float A[2048]. Each array element is 4 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 Kbytes, with block (line) size of 16 Bytes.a. Which elements of the array conflict with element A[0] in the data cache? Justify your answer briefly.b. 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.Correct answer is '(a)'. Can you explain this answer? for Computer Science Engineering (CSE) 2024 is part of Computer Science Engineering (CSE) preparation. The Question and answers have been prepared according to the Computer Science Engineering (CSE) exam syllabus. Information about In a C program, an array is declared as float A[2048]. Each array element is 4 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 Kbytes, with block (line) size of 16 Bytes.a. Which elements of the array conflict with element A[0] in the data cache? Justify your answer briefly.b. 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.Correct answer is '(a)'. Can you explain this answer? covers all topics & solutions for Computer Science Engineering (CSE) 2024 Exam. Find important definitions, questions, meanings, examples, exercises and tests below for In a C program, an array is declared as float A[2048]. Each array element is 4 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 Kbytes, with block (line) size of 16 Bytes.a. Which elements of the array conflict with element A[0] in the data cache? Justify your answer briefly.b. 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.Correct answer is '(a)'. Can you explain this answer?.
In a C program, an array is declared as float A[2048]. Each array element is 4 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 Kbytes, with block (line) size of 16 Bytes.a. Which elements of the array conflict with element A[0] in the data cache? Justify your answer briefly.b. 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.Correct answer is '(a)'. Can you explain this answer? for Computer Science Engineering (CSE) 2024 is part of Computer Science Engineering (CSE) preparation. The Question and answers have been prepared according to the Computer Science Engineering (CSE) exam syllabus. Information about In a C program, an array is declared as float A[2048]. Each array element is 4 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 Kbytes, with block (line) size of 16 Bytes.a. Which elements of the array conflict with element A[0] in the data cache? Justify your answer briefly.b. 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.Correct answer is '(a)'. Can you explain this answer? covers all topics & solutions for Computer Science Engineering (CSE) 2024 Exam. Find important definitions, questions, meanings, examples, exercises and tests below for In a C program, an array is declared as float A[2048]. Each array element is 4 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 Kbytes, with block (line) size of 16 Bytes.a. Which elements of the array conflict with element A[0] in the data cache? Justify your answer briefly.b. 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.Correct answer is '(a)'. Can you explain this answer?.
Solutions for In a C program, an array is declared as float A[2048]. Each array element is 4 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 Kbytes, with block (line) size of 16 Bytes.a. Which elements of the array conflict with element A[0] in the data cache? Justify your answer briefly.b. 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.Correct answer is '(a)'. Can you explain this answer? in English & in Hindi are available as part of our courses for Computer Science Engineering (CSE).
Download more important topics, notes, lectures and mock test series for Computer Science Engineering (CSE) Exam by signing up for free.
Here you can find the meaning of In a C program, an array is declared as float A[2048]. Each array element is 4 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 Kbytes, with block (line) size of 16 Bytes.a. Which elements of the array conflict with element A[0] in the data cache? Justify your answer briefly.b. 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.Correct answer is '(a)'. Can you explain this answer? defined & explained in the simplest way possible. Besides giving the explanation of
In a C program, an array is declared as float A[2048]. Each array element is 4 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 Kbytes, with block (line) size of 16 Bytes.a. Which elements of the array conflict with element A[0] in the data cache? Justify your answer briefly.b. 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.Correct answer is '(a)'. Can you explain this answer?, a detailed solution for In a C program, an array is declared as float A[2048]. Each array element is 4 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 Kbytes, with block (line) size of 16 Bytes.a. Which elements of the array conflict with element A[0] in the data cache? Justify your answer briefly.b. 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.Correct answer is '(a)'. Can you explain this answer? has been provided alongside types of In a C program, an array is declared as float A[2048]. Each array element is 4 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 Kbytes, with block (line) size of 16 Bytes.a. Which elements of the array conflict with element A[0] in the data cache? Justify your answer briefly.b. 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.Correct answer is '(a)'. Can you explain this answer? theory, EduRev gives you an
ample number of questions to practice In a C program, an array is declared as float A[2048]. Each array element is 4 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 Kbytes, with block (line) size of 16 Bytes.a. Which elements of the array conflict with element A[0] in the data cache? Justify your answer briefly.b. 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.Correct answer is '(a)'. Can you explain this answer? tests, examples and also practice Computer Science Engineering (CSE) tests.
|
|
Explore Courses for Computer Science Engineering (CSE) exam
|
|
Suggested Free Tests
Signup for Free!
Signup to see your scores go up within 7 days! Learn & Practice with 1000+ FREE Notes, Videos & Tests.
|
© EduRev
|
Education Revolution
|
|
Signup to see your scores
go up within 7 days!
Access 1000+ FREE Docs, Videos and Tests
Takes less than 10 seconds to signup