Introduction

This question tested the following topics/items:

• Client/Server Network Architecture
• Peer-to-Peer (P2P) Network Architecture
• Advantages and Disadvantages of Network Types
• Network Security
• Firewalls
• Firewall Configuration and Maintenance
• Security Patches and Updates
• Network Protocols
• Fiber Distributed Data Interface (FDDI)
• Ethernet Protocol
• Network Topologies (Token Ring, Star)
• Physical Media in Networking (Fiber Optics, Copper Cables)
• Open Systems Interconnection (OSI) Model
• Transport Layer Responsibilities
• Network Layer Responsibilities
• Data Segmentation and Reassembly
• End-to-End Communication
• Error Detection and Correction
• Data Flow Control
• Packet Routing and Forwarding
• IP Addressing
• Wireless Networks
• Advantages of Wireless Connectivity
• Wireless Router Setup and Configuration
• Mobile Data Communication
• General Packet Radio Service (GPRS)
• Cellular Network Technology
• Applications of GPRS (e.g., POS Systems, MMS, Tracking)
• Network Performance and Efficiency Considerations

1. Introduction
2. Part a)
3. Part b) i)
4. Part b) ii)
5. Part c)
6. Part d)
7. Part e)
8. Part f) i)
9. Part f) ii)

Part a)

A client server network has one or more computer nodes providing all the services needed by all other client computers.  E.g web server, ftp server etc.

Hardware and resources are easily configured.

Servers can be administered to allow connection only to authorized computers on the network thus benefit from better security.

The sever can easily undergo regular backups easily since all data is centralized.

For P2P each computer on the network can act as a server for all others on the network.

Each node on the P2P is not guaranteed to be powerful, and mostly have the average power as clients.

This configuration is difficult to keep secure, additional third party software is usually required to implement security.

P2P networks add strain on the network as more peers are added to the network since sometimes one node would be responsible for routing a lot of traffic to all others. It is impractical to attempt backup on this network configuration.

Part b) i)

A firewall is a hardware and/or software security measure which protects against external network threats in the form of unauthorized connections or attacks. It also filters connections within the network to prevent malicious activity.

Part b) ii)

New computer threats emerge every day, and thus the firewall must apply frequent updates which protect against new computer threats.

Part c)

Fddi uses fibre optic cables , and transfers data using token ring topology, and can be much faster over long distances (200 Km). The ring technology includes additional rings in the event that one ring fails, another exists to carry on data communication.

Ethernet mainly uses copper wires, and transfers data using packet switching (Star Topology), over shorter distances (100 m) and is slower than FDDI. Ethernet does not typically have backup lines to help prevent network failure.

Part d)

The Transport layer is responsible for segmenting packets and reliable communications across the transport layer by implementing end to end communication with error checking and data flow control (speed changes between networks)

The network layer is responsible for efficiently routing data from network to network by choosing the best paths using IP protocol which gives each node on the network a unique IP address.

Part e)

• It is convenient, the wireless signals penetrate walls and floors in all directions. Cable installation from floor to floor is not required.
• It allows for additional mobility within the range oof connection
• Overall, It is cheaper, since wired cables are not needed to be used.

Part f) i)

It is designed to provide wireless network connectivity over a cellular network so that traditional network tasks, e.g. connecting to the internet, can be facilitated. It was developed for wireless POS systems, MMS, tracking and navigation , wireless electricity meters , etc.

Part f) ii)

• Allowing for wireless POS payments over the cell network when purchasing groceries without needing a phone line.
• Allowing the electric company to carry out wireless meter readings without having to perform a physical house visit to read the meter.

© 2023  Vedesh Kungebeharry. All rights reserved. 

Introduction

This question tested the following operating system concepts:

1. Introduction
2. Part a)
3. Part b) i)
4. Part b) ii)
5. Part b) iii)
6. Part c)
7. Part d)
   1. Further explanation
8. Part e) i)
9. Part e) ii)
10. Part e) iii)
11. Footnotes

Part a)

A program is a set of computer instructions that is stored on secondary storage, and a process is a program that is currently being executed on the cpu, it’s instructions and data are stored in main memory – RAM and registers in the CPU.

Part b) i)

It’s time on the CPU has expired.

Part b) ii)

It is waiting on data from an IO operation and cannot continue until it receives the data.

Part b) iii)

The process has completed all of its instructions and no longer needs any of it’s previous system resources.

Part c)

P1 is using d1,

P2 is using d1,

Eventually p1 needs d2 also, it is put into a waiting state.

P2 needs d1, but d1 is in use by p1 and p1 is waiting on p2 to release d2.

P2 will be put into a waiting state

Both process are waiting on each other and will not release the DVD resources that they are allocated, thus neither process can complete and thus we say they are deadlocked.

Part d)

Windows 10, is a multitasking operating system, tasks share time on the CPU.

Linux is a multiprocessing operating system allowing for the running of separate tasks on separate CPUs, thus achieving higher performance.

Further explanation

All present-day operating systems support multitasking and multiprocessing, there are cases where multiprocessing may not be used, e.g where an embedded system is designed for specific task that doesn’t require much processing power.

Part e) i)

Sometimes many processes need to be run simultaneously, and the needs for physical memory can exceed the actual memory that is available.

Part e) ii)

Multiple page frames are created for each process. Ideally, the currently running’s process’s frames are stored in physical ram, and all other ready or waiting processes are stored in ram. As more processes are run which exceed the physical ram capacity, the page frames for the ready and waiting processes are swapped out of physical ram onto the page file on the hard disk to accommodate running processes. When a running process is put into waiting/ready state, it may be put on the virtual page file, and  the next process to be run can be put from the virtual page file back into the physical ram to be run.

Part e) iii)

The system can operate inefficiently since a lot of swapping may occur, and this is dependent on the much slower hard disk memory access for each swap. This condition is know as thrashing.

Footnotes

1. TA-Note ↩︎

© 2023  Vedesh Kungebeharry. All rights reserved. 

Part a) i)

int numseq[21];

Further explanation  

21 locations needed for numbers 0 to 20)

Part a) ii)

19

Part a) iii)

Suggested response

int binarySearch(int key, int list[], int low, int high) {
    int result = -1; 
    int keyFound = 0; //sentinel to end loop on a successful search

    while (low <= high && !keyFound) {
        int middle = (high-low) / 2 + low;//determine middle of the range

        if (key == list[middle]) 
        {
            result = middle;
            keyFound=1; // Key found, exit loop

        } 
        else if (key < list[middle]) 
        { 
            high = middle - 1; // Narrow the search to the lower half
        } 
        else 
        
            low = middle + 1; // Narrow the search to the upper half
        }
    }

    return result; //Returns -1 if not found, 
                   //otherwise, the index of the key
}

Further Explanation

(See this note¹)

int binarySearch(int key, int list[], int low, int high) {
    int result = -1; //result is -1 if not found
    int keyFound = 0; //sentinel to end loop on a successful search

    while (low <= high && !keyFound) //while there is more locations 
                                     //to search and the key has not 
                                     //been found
    {
        int middle = (high-low) / 2 + low;//determine middle of the range

        if (key == list[middle]) //if the key is found..
        {
            result = middle;
            keyFound=1; // Key found, exit loop
        } 
        else if (key < list[middle]) //if key may be in the lower half...
        { 
            high = middle - 1; // Narrow the search to the lower half
        } 
        else //else the key may be in the upper half
        {
            low = middle + 1; // Narrow the search to the upper half
        }
    }

    return result; // Returns -1 if not found, otherwise the key

Response using recursion

int binarySearch(int key, int  list[], int low, int high)
{
    
    int result=-1;
    int middle = (high-low)/2+low;

    if (low<=high)//if low and high have not crossed...
    {
        if(key==list[middle])//if the key is found....
        {
            result=middle;
            return result
        }
        else//the key was not found
        {
            if(key<list[middle])
            {                   

               
                result= binarySearch(key,list,low,middle-1);
                return result;
            }

            else 
            {
                result= binarySearch(key,list,middle+1,high);
                return result;
            }

        }
    }
    return result;

Further Explanation

int binarySearch(int key, int  list[], int low, int high)
{
    /*we use low and high to represent a
    portion of the array. Initially, low and high
    points to the start of the array and the end of
    the array respectively. Middle indexes the location
     to the middle of the array.
    */
    int result=-1;//-1 represents a failed search
    int middle = (high-low)/2+low;

    if (low<=high)//if low and high have not crossed...
    {
        if(key==list[middle])//if the key is found....
        {
            result=middle;
            return result;//return the current index and exit function
        }
        else//the key was not found
        {
            if(key<list[middle])//if the key would be found
            {                   //from low to middle

               //we now search the lower half
                result= binarySearch(key,list,low,middle-1);
                return result;
            }

            else //key would be found from middle to high
            {
                result= binarySearch(key,list,middle+1,high);//we now search the upper half
                return result;
            }

        }
    }
    return result;

Part b i)

//assume integer array
void swap(int array[], int a, int b) {
    int temp = array[a];
    array[a] = array[b];
    array[b] = temp;
}

Part b ii)

• The array is traversed from index 0 to n and the location of the smallest element is determined.
• The smallest element is swapped with the first element that was traversed.
• This is repeated on the unsorted portion of the array by  incrementing the starting element that is traversed to 1 to n, then 2 to n, 3 to n, … until n-1 to n.

Part b iii)

void selectionSort (int arr[], int low, int high)
{
    for (int i = low; i<high; i++)
    {
        int smallest = getSmallest(arr,i,high);
        swap(arr,i,smallest);
    }
}

Further explanation

The following complete program in C tests that the selection sort is working.

#include <stdio.h>
 
//function declarations
void selectionSort(int arr[], int low, int high);
void swap(int array[], int a, int b);
int getSmallest(int arr[], int low, int high);
 
int main()
{
    int array[] = {64, 25, 12, 22, 11};
    int size = sizeof(array) / sizeof(array[0]);
   
 
    printf("Original array: ");
    for (int i = 0; i < size; i++)
        printf("%d ", array[i]);
    printf("\n");
 
    //sort the array
    selectionSort(array, 0, size-1);
 
    printf("Sorted array: ");
    for (int i = 0; i < size; i++)
        printf("%d ", array[i]);
    printf("\n");
 
    printf("\nEnding program...");
 
    return 0;
}
 
void selectionSort(int arr[], int low, int high) {
    // Traverse up to the
    // second-to-last element
    for (int i = low; i < high; i++)
    {
        /*find the index of the smallest
        element in the range
        */
        int smallest = getSmallest(arr, i, high);
       
        /*if the smallest element
        should be put in the first
        position that was
        traversed ...
        */
        if(arr[smallest]<arr[i])
            swap(arr, i, smallest);//swap elements
    }
}
 
void swap(int array[], int a, int b) {
    int temp = array[a];
    array[a] = array[b];
    array[b] = temp;
}
 
int getSmallest(int arr[], int low, int high) {
    int smallestIndex = low;
    // Include the high in the search
    for (int i = low + 1; i <= high; i++)
    {
        if (arr[i] < arr[smallestIndex]) {
            smallestIndex = i;
        }
    }
    return smallestIndex;
}

Part c)

(See this note²)

Footnotes

1. https://islandclass.org/2020/11/12/binary-search-implementation/ ↩︎
2. https://islandclass.org/2020/11/04/bubble-sort-implementation-demonstration/ ↩︎

Navigation

1. Part a) i)
   1. Further explanation  
2. Part a) ii)
3. Part a) iii)
   1. Suggested response
   2. Further Explanation
   3. Response using recursion
   4. Further Explanation
4. Part b i)
5. Part b ii)
6. Part b iii)
7. Further explanation
8. Part c)
9. Footnotes
10. Navigation

© 2023  Vedesh Kungebeharry. All rights reserved. 

1. Part a)
2. Part b)
   1. Explanation
3. Part c)
4. Part d) i)
   1. Explanation/Working:
5. Part d) ii)
6. Part d) iii)
7. Part d) iv)
8. Links to Notes
   1. Attributions to media used in this post
9. Footnotes

Part a)

AND Gate:

  A | B | A AND B
  ---------------
  0 | 0 |    0
  0 | 1 |    0
  1 | 0 |    0
  1 | 1 |    1

Or Gate:

  A | B | A OR B
  ---------------
  0 | 0 |    0
  0 | 1 |    1
  1 | 0 |    1
  1 | 1 |    1

Not Gate:

  A | NOT A
  ---------
  0 |   1
  1 |   0

See this note¹

Part b)

Suggested response:

XOR truth table:

Output is 1 in XOR for (NOT A AND B) OR (A AND NOT B)

Circuit:

Explanation

Assume we want to use an AND gate as a building block for our resulting circuit. Wherever we have an output of 1  it means that the inputs to that and gate should also be 1 .

If we imagine an AND gate being the last gate before the output, wherever there is a 1 we need to understand that the inputs to that gate would have to be 1.

-For each output that produces a 1, we modify the variable input to match  the modded input listed in the specific row of the table:

We see that either row ii) OR row iii)  produces a 1, i.e

(NOT A AND B) OR (A AND NOT B)

From this expression, we draw the circuit as shown in the suggested response above.

Part c)

Data Lines (Input) are denoted as x₁…x₄, select line are denoted as s₁ and s₂, Output is denoted as f

Alternative Diagram in ASCII :

        _______________________
       |        4-to-1         |
D0 ----|      Multiplexer      |
       |                       |
D1 ----|                       |---> Output
       |                       |
D2 ----|                       |
       |                       |
D3 ----|_______________________|
              |         |
              |         |
              |         |
              |         |
              S1        S0
Data Lines (Input) are denoted as D0...D3, select line are denoted as S0 and S1.

See Note²

Part d) i)

16+8+0+2+1 =27

Explanation/Working:

(0×2⁷)+(0×2⁶)+(0×2⁵)+(1×2⁴)+(1×2³)+(0×2²)+(1×2¹)+(1×2⁰)

0+0+0+16+8+0+2+1=27

Part d) ii)

  0111 +
  1110
———-
10101 ← this result cannot be stored in 4 bits.

Part d) iii)

Largest number = 0111 =7 (Show conversion)
Smallest number= 1111= -ve 7 (Show conversion)

Part d) iv)

Suggestion solution 1:

Algorithm, copy all numbers from LSB to MSB up to and including the first 1, then flip remaining bits in that order, i.e
5= 0101

Applying algorithm : 1011

Suggestion solution 2:

+5= 0101
Ones = 0101+1 = 1010
Twos = 1010+1 = 1011

Links to Notes

Attributions to media used in this post

Inductiveload, Public domain, via Wikimedia Commons

Footnotes

1. https://islandclass.org/2021/10/20/logic-gates-formal-introduction/ ↩︎
2. https://islandclass.org/2021/10/21/multiplexers/ ↩︎

© 2023  Vedesh Kungebeharry. All rights reserved. 

1. Part a) i)
2. Part a) ii)
3. Part a) iii)
4. Part b) i)
5. Part b) ii)
6. Part b) iii)
7. Part c)
8. Part d) i)
9. Part d) ii)
10. Part d) iii)

Part a) i)

        _______________________
       |        4-to-1         |
D0 ----|      Multiplexer      |
       |                       |
D1 ----|                       |---> Output
       |                       |
D2 ----|                       |
       |                       |
D3 ----|_______________________|
              |         |
              |         |
              |         |
              |         |
              S1        S0

Part a) ii)

Set the select inputlines to 01 to select the 2^nd line, and when input from the 4^th line is needed after 1 second (i.e i3), set the select input lines to 11

Part a) iii)

– It always exists in 1 of 2 stable states.
-It can retain its state to achieve storage (in the case the set goes from 1 to 0)

Can be used in RAM Arrays (to implement 1 bit storage) or to Implement a Ripple Counter

Part b) i)

1101

(First bit is 1 for to represent a negative value,

working for 5₁₀ to binary :

       2 | 5  

       2 |2  remainder 1

       2 |1  remainder 0 

            0  remainder 1

i.e 5₁₀  = 101₂

combining the result we get 1101₂

)

Part b) ii)

1010 (flipped bits of 0101)

Part b) iii)

1010 +1 = 1011

Part c)

(Show binary-decimal conversions)

For an unbiased exponent and unnormalized mantissa:

sign is -ve, Exponent = 2, Mantissa= 0101

i.e -0.0101 x 2_­² = -1.01

-1.01₂   =  (-1 x 2⁰)+ (0 x 2^-1)+ (1 x 2^-2)

          = -1 + 0+ ¼

          = -1.25

Part d) i)

Not (Unary operator)

Part d) ii)

AND

Part d) iii)

OR

© 2023  Vedesh Kungebeharry. All rights reserved.