Given Information : The definition for the code is mentioned below: //Traverse through the grid for (i =0; i < 16; i++) { for (j = 0; j < 16; j++) { //add values of x into grid total_x += grid[j][i].x; //add values of y into grid total_y += grid[j][i].y; } }

Question

Want to see the full answer?

Answer 1

Question

Chapter 6.5, Problem 6.19PP

A.

Program Plan Intro

Given Information:

The definition for the code is mentioned below:

//Traverse through the grid

for (i =0; i < 16; i++)

{

for (j = 0; j < 16; j++)

{

//add values of x into grid

total_x += grid[j][i].x;

//add values of y into grid

total_y += grid[j][i].y;

}

}

B.

Program Plan Intro

Given Information:

The definition for the code is mentioned below:

//Traverse through the grid

for (i =0; i < 16; i++)

{

for (j = 0; j < 16; j++)

{

//add values of x into grid

total_x += grid[j][i].x;

//add values of y into grid

total_y += grid[j][i].y;

}

}

C.

Explanation of Solution

Miss rate:

The cache can only hold half of the elements in the array, so that means that a read to grid[8][0] will evict the block that was loaded when we read grid[0][0]. Since this block also contained grid[0][1], the first read of grid[0][1] will be a miss.

Hence, each iteration will have one hit and one miss.

This means one will have 256 hits and 256 misses...

D.

Explanation of Solution

New Miss Rate:

If the cache were twice as big the n it could hold the entire grid array and the only misses would be the initial cold miss...

Expert Solution & Answer

Want to see the full answer?

Check out a sample textbook solution

See solution

Students have asked these similar questions

(c) The following Sigma 16 program has been loaded into memory at address 0000: load R3,y[RO] load R4,x[RO] lea R5, 2[RO] sub R1,R4,R3 mul R2,R1,R5 store R2,w[RO] trap RO,RO,RO x data 10 y data 12 w data 0 Show the content of the memory writing hexadecimal representation and using a table with 3 columns: the memory address, the contents of that memory address, and an explanation of what "the content (of that memory address) means". As a reference, here are the opcodes for RRR instructions: add 0, sub 1, mul 2, trap c. And here the opcodes for RX instructions: lea 0, load 1, store 2. [7]

6

(d) Given memory holes (i.e., unused memory blocks) of 100K, 500K, 200K, 300K and 600K (in address order) as shown below, how would each of the first-fit, next-fit, best- fit algorithms allocate memory requests of 120K, 320K, 280K, 90K and 210K (in this order). The shaded areas are used/allocated regions that are not available. 100k 500k 200k 300k 600k Figure 2: Current status of main memory

Answer 2

Question

Chapter 6.5, Problem 6.19PP

A.

Program Plan Intro

Given Information:

The definition for the code is mentioned below:

//Traverse through the grid

for (i =0; i < 16; i++)

{

for (j = 0; j < 16; j++)

{

//add values of x into grid

total_x += grid[j][i].x;

//add values of y into grid

total_y += grid[j][i].y;

}

}

B.

Program Plan Intro

Given Information:

The definition for the code is mentioned below:

//Traverse through the grid

for (i =0; i < 16; i++)

{

for (j = 0; j < 16; j++)

{

//add values of x into grid

total_x += grid[j][i].x;

//add values of y into grid

total_y += grid[j][i].y;

}

}

C.

Explanation of Solution

Miss rate:

The cache can only hold half of the elements in the array, so that means that a read to grid[8][0] will evict the block that was loaded when we read grid[0][0]. Since this block also contained grid[0][1], the first read of grid[0][1] will be a miss.

Hence, each iteration will have one hit and one miss.

This means one will have 256 hits and 256 misses...

D.

Explanation of Solution

New Miss Rate:

If the cache were twice as big the n it could hold the entire grid array and the only misses would be the initial cold miss...

Expert Solution & Answer

Want to see the full answer?

Check out a sample textbook solution

See solution

Answer 3

Question

Chapter 6.5, Problem 6.19PP

A.

Program Plan Intro

Given Information:

The definition for the code is mentioned below:

//Traverse through the grid

for (i =0; i < 16; i++)

{

for (j = 0; j < 16; j++)

{

//add values of x into grid

total_x += grid[j][i].x;

//add values of y into grid

total_y += grid[j][i].y;

}

}

B.

Program Plan Intro

Given Information:

The definition for the code is mentioned below:

//Traverse through the grid

for (i =0; i < 16; i++)

{

for (j = 0; j < 16; j++)

{

//add values of x into grid

total_x += grid[j][i].x;

//add values of y into grid

total_y += grid[j][i].y;

}

}

C.

Explanation of Solution

Miss rate:

The cache can only hold half of the elements in the array, so that means that a read to grid[8][0] will evict the block that was loaded when we read grid[0][0]. Since this block also contained grid[0][1], the first read of grid[0][1] will be a miss.

Hence, each iteration will have one hit and one miss.

This means one will have 256 hits and 256 misses...

D.

Explanation of Solution

New Miss Rate:

If the cache were twice as big the n it could hold the entire grid array and the only misses would be the initial cold miss...

Expert Solution & Answer

Want to see the full answer?

Check out a sample textbook solution

See solution

Answer 4

Question

Chapter 6.5, Problem 6.19PP

A.

Program Plan Intro

Given Information:

The definition for the code is mentioned below:

//Traverse through the grid

for (i =0; i < 16; i++)

{

for (j = 0; j < 16; j++)

{

//add values of x into grid

total_x += grid[j][i].x;

//add values of y into grid

total_y += grid[j][i].y;

}

}

B.

Program Plan Intro

Given Information:

The definition for the code is mentioned below:

//Traverse through the grid

for (i =0; i < 16; i++)

{

for (j = 0; j < 16; j++)

{

//add values of x into grid

total_x += grid[j][i].x;

//add values of y into grid

total_y += grid[j][i].y;

}

}

C.

Explanation of Solution

Miss rate:

The cache can only hold half of the elements in the array, so that means that a read to grid[8][0] will evict the block that was loaded when we read grid[0][0]. Since this block also contained grid[0][1], the first read of grid[0][1] will be a miss.

Hence, each iteration will have one hit and one miss.

This means one will have 256 hits and 256 misses...

D.

Explanation of Solution

New Miss Rate:

If the cache were twice as big the n it could hold the entire grid array and the only misses would be the initial cold miss...

Expert Solution & Answer

Want to see the full answer?

Check out a sample textbook solution

See solution

Answer 5

Chapter 6.5, Problem 6.19PP

A.

Program Plan Intro

Given Information:

The definition for the code is mentioned below:

//Traverse through the grid

for (i =0; i < 16; i++)

{

for (j = 0; j < 16; j++)

{

//add values of x into grid

total_x += grid[j][i].x;

//add values of y into grid

total_y += grid[j][i].y;

}

}

B.

Program Plan Intro

Given Information:

The definition for the code is mentioned below:

//Traverse through the grid

for (i =0; i < 16; i++)

{

for (j = 0; j < 16; j++)

{

//add values of x into grid

total_x += grid[j][i].x;

//add values of y into grid

total_y += grid[j][i].y;

}

}

C.

Explanation of Solution

Miss rate:

The cache can only hold half of the elements in the array, so that means that a read to grid[8][0] will evict the block that was loaded when we read grid[0][0]. Since this block also contained grid[0][1], the first read of grid[0][1] will be a miss.

Hence, each iteration will have one hit and one miss.

This means one will have 256 hits and 256 misses...

D.

Explanation of Solution

New Miss Rate:

If the cache were twice as big the n it could hold the entire grid array and the only misses would be the initial cold miss...

Answer 6

Chapter 6.5, Problem 6.19PP

A.

Program Plan Intro

Given Information:

The definition for the code is mentioned below:

//Traverse through the grid

for (i =0; i < 16; i++)

{

for (j = 0; j < 16; j++)

{

//add values of x into grid

total_x += grid[j][i].x;

//add values of y into grid

total_y += grid[j][i].y;

}

}

Answer 7

Chapter 6.5, Problem 6.19PP

A.

Program Plan Intro

Given Information:

The definition for the code is mentioned below:

//Traverse through the grid

for (i =0; i < 16; i++)

{

for (j = 0; j < 16; j++)

{

//add values of x into grid

total_x += grid[j][i].x;

//add values of y into grid

total_y += grid[j][i].y;

}

}

Answer 8

B.

Program Plan Intro

Given Information:

The definition for the code is mentioned below:

//Traverse through the grid

for (i =0; i < 16; i++)

{

for (j = 0; j < 16; j++)

{

//add values of x into grid

total_x += grid[j][i].x;

//add values of y into grid

total_y += grid[j][i].y;

}

}

Answer 9

B.

Program Plan Intro

Given Information:

The definition for the code is mentioned below:

//Traverse through the grid

for (i =0; i < 16; i++)

{

for (j = 0; j < 16; j++)

{

//add values of x into grid

total_x += grid[j][i].x;

//add values of y into grid

total_y += grid[j][i].y;

}

}

Answer 10

C.

Explanation of Solution

Miss rate:

The cache can only hold half of the elements in the array, so that means that a read to grid[8][0] will evict the block that was loaded when we read grid[0][0]. Since this block also contained grid[0][1], the first read of grid[0][1] will be a miss.

Hence, each iteration will have one hit and one miss.

This means one will have 256 hits and 256 misses...

Answer 11

C.

Explanation of Solution

Miss rate:

The cache can only hold half of the elements in the array, so that means that a read to grid[8][0] will evict the block that was loaded when we read grid[0][0]. Since this block also contained grid[0][1], the first read of grid[0][1] will be a miss.

Hence, each iteration will have one hit and one miss.

This means one will have 256 hits and 256 misses...

Answer 12

D.

Explanation of Solution

New Miss Rate:

If the cache were twice as big the n it could hold the entire grid array and the only misses would be the initial cold miss...

Answer 13

D.

Explanation of Solution

New Miss Rate:

If the cache were twice as big the n it could hold the entire grid array and the only misses would be the initial cold miss...

Answer 14

Expert Solution & Answer

Answer 15

Expert Solution & Answer

Answer 16

Want to see the full answer?

Check out a sample textbook solution

See solution

Answer 17

Ch. 6.1 - Prob. 6.1PP Ch. 6.1 - Prob. 6.2PP Ch. 6.1 - Prob. 6.3PP Ch. 6.1 - Prob. 6.4PP Ch. 6.1 - Prob. 6.5PP Ch. 6.1 - Prob. 6.6PP Ch. 6.2 - Prob. 6.7PP Ch. 6.2 - Prob. 6.8PP Ch. 6.4 - Prob. 6.9PP Ch. 6.4 - Prob. 6.10PP

Given Information : The definition for the code is mentioned below: //Traverse through the grid for (i =0; i &lt; 16; i++) { for (j = 0; j &lt; 16; j++) { //add values of x into grid total_x += grid[j][i].x; //add values of y into grid total_y += grid[j][i].y; } }

Given Information: The definition for the code is mentioned below: //Traverse through the grid for (i =0; i < 16; i++) { for (j = 0; j < 16; j++) { //add values of x into grid total_x += grid[j][i].x; //add values of y into grid total_y += grid[j][i].y; } }

Given Information: The definition for the code is mentioned below: //Traverse through the grid for (i =0; i < 16; i++) { for (j = 0; j < 16; j++) { //add values of x into grid total_x += grid[j][i].x; //add values of y into grid total_y += grid[j][i].y; } }

Explanation of Solution

Explanation of Solution

New Miss Rate: If the cache were twice as big the n it could hold the entire grid array and the only misses would be the initial cold miss...

Want to see the full answer?

Chapter 6 Solutions

Given Information : The definition for the code is mentioned below: //Traverse through the grid for (i =0; i < 16; i++) { for (j = 0; j < 16; j++) { //add values of x into grid total_x += grid[j][i].x; //add values of y into grid total_y += grid[j][i].y; } }

Given Information:

The definition for the code is mentioned below:

//Traverse through the grid

for (i =0; i < 16; i++)

{

for (j = 0; j < 16; j++)

{

//add values of x into grid

total_x += grid[j][i].x;

//add values of y into grid

total_y += grid[j][i].y;

}

}

Given Information:

The definition for the code is mentioned below:

//Traverse through the grid

for (i =0; i < 16; i++)

{

for (j = 0; j < 16; j++)

{

//add values of x into grid

total_x += grid[j][i].x;

//add values of y into grid

total_y += grid[j][i].y;

}

}

New Miss Rate:

If the cache were twice as big the n it could hold the entire grid array and the only misses would be the initial cold miss...