Question

I need the following answered for an Operating Systems course

Describe the order in which the elements of the A array are accessed in the rows() and columns() functions. What is the main difference?

Include the output of each run and show what the average throughput is

Is there a difference in the throughput or time required to execute “rows()” versus “columns()”? If there is a difference, explain the cause of the difference

Answer 1

Array:

• Array is the part of the data structure.
• Array is a collection of similar data elements.
• It has same data type.
• Array are stored in consecutive memory location.
• Array element are accessed by index value.

The order in which the elements of the A array are accessed in the rows() and columns() functions:

Programe to access element of array by cloumn and row:

#include<iostream> 
using namespace std; 
int main() 
{ 
    int A[3][3] ={{1, 2, 3}, 
            {4, 5, 6}, 
            {7, 8, 9}};
    for (int i = 0; i < 3; i++)
    { 
        cout<<"\n";
        for (int j = 0; j < 3; j++) 
        { 
            cout<<"\t";
            cout << A[i][j]; 
        } 
    } 
    return 0;
} 

The Output of each run and show what the average throughput is:

By row:

• when we run the programe first time it will print 1.
• 2 time run it will print 2.
• 3 time print 3. And so on

By column:

• 1 time print 1.
• 2 time print 4.
• 3 time print 7. And so on.

Process:

Difference: " Showed in the process"

• In row: The consecutive element are situated next row of each other.
• In column: The consecutive elements are situated next to the column.

Time required to execute “rows()” versus “columns()” function:

Programe :

#include <stdio.h>                     /* Library files*/
#include <time.h>                          
#include <conio.h>
#define MAX 100                        /*define array capacity*/ 
 
int A[MAX][MAX] = {0};                 /* declaration of array*/
void row() {                           /* row function*/
  int i, j; 
  for (i = 0; i < MAX; i++) { 
    for (j = 0; j < MAX; j++) { 
     A[i][j]++; 
    } 
  } 
}                                      /* Ending of row function*/
 
void column() {                        /* column function*/
  int i, j; 
  for (i = 0; i < MAX; i++) { 
    for (j = 0; j < MAX; j++) { 
      A[j][i]++; 
    } 
  } 
}                                    /* ending of row function*/

int main() {                          /* main function*/
  int i, j; 
  clock_t t = clock(); 
  row(); 
  t = clock() - t; 
  printf("Row access time :%f s\n",  
                t / (float)CLOCKS_PER_SEC); 
  t = clock(); 
  column(); 
  t = clock() - t; 
  printf("Column access time :%f s\n",  
               t / (float)CLOCKS_PER_SEC); 
  return 0; 
} 

Output:

Here we can see the difference in time required to execute “rows()” versus “columns()” function Because the reason is same as diffrenece:

• In row: The consecutive element are situated next row of each other so that it will took less time.
• In column: The consecutive elements are situated next to the column so that it will took more time.

Note:- Excuation time depends on your system capacity.