P3 – Page Replacement Algorithms
CS3310 Operating Systems

Page Replacement:

Complete the program that implements the FIFO and LRU algorithms presented in the chapter and calculates the number of page faults generated given a particular reference string. Implement the replacement algorithms such that the number of page frames can vary. Assume that demand paging is used.

Required Modifications:

• Implement LRU and FIFO algorithms
  • Add appropriate data structures and private helper methods to LRU.h and FIFO.h
  • Implement the insert() method in LRU.cpp and FIFO.cpp as well as any helper functions you specify in the header files.
• ReplacementAlgorithm.h should not be modified.
• testPR.cpp may be modified to facilitate testing and/or analysis. Comment appropriately.
  • You may want to modify the number of pages MAX_PAGE_NUMBER.
• reference_string.txt is given as an example reference string that can be opened via the command line arguments. You must create at least one more interesting and representative reference string and use one of them in your testing and analysis. If an input file is not specified, a random sequence of page numbers is generated.

Extra Credit (+30%)

• Create the OPT (optimal) replacement algorithm and compare its results with LRU & FIFO in your analysis. The implementation will have to be slightly different than the LRU & FIFO algorithm classes. If you make any changes to ReplacementAlgorithm.h or substantial changes to testPR.cpp, please be sure to document them appropriately

Project Code:

LRU.h

#ifndef _LRU_H
#define _LRU_H

#include <iostream>
#include "ReplacementAlgorithm.h"

class LRU : public ReplacementAlgorithm {
public:
LRU(int numPageFrames);
void insert(int pageNumber) override;

private:
  
  
  
// data structure to store the int page frame list
//<data type> frameList;
};

#endif

LRU.cpp

#include "LRU.h"

LRU::LRU(int numPageFrames) : ReplacementAlgorithm(numPageFrames) {
pageFaultCount = 0;
}

void LRU::insert(int pageNumber)
{
// Implement LRU page replacement algorithm
// Increment pageFaultCount if a page fault occurs

}

FIFO.h

#ifndef _FIFO_H
#define _FIFO_H

#include <iostream>
#include "ReplacementAlgorithm.h"

class FIFO : public ReplacementAlgorithm {
public:
FIFO(int numPageFrames);
void insert(int pageNumber) override;

private:
// data structure to store the int page frame list
//<data type> frameList;
};

#endif

FIFO.cpp

#include "FIFO.h"

FIFO::FIFO(int numPageFrames) : ReplacementAlgorithm(numPageFrames) {
pageFaultCount = 0;
}

void FIFO::insert(int pageNumber)
{
// Implement FIFO page replacement algorithm
// Increment pageFaultCount if a page fault occurs

}

Name the special purpose registers in ARM ISA

<Python coding question string practice>

Can anyone please answer these python string questions??

1. Write a function called username that takes as parameters a person's first and last names and prints out his or her username formatted as the last name followed by an underscore and the first initial. For example, username("Martin", "freeman") should print the string "freeman_m".

2. Write a function called letters that takes as a parameter a string and prints out the characters of the string, one per line. For example letters("abc") should print

a

b

c

3. Write a function called backward that takes as a parameter a string and prints out the characters of the string in reverse order, one per line. For example backward("abc") should print

c

b

a

4. Write a function called noVowels that takes as a parameter a string and returns the string with all the vowels removed. For example, noVowels("this is an example.") should return "the s n xmpl.".

Create a program called BubleSort.java that implements the Bubble Sort algorithm (The Art of Computer Programming - Donald Knuth). The algorithm is as follows: The program should be able to do the following: accepts one command line parameter. The parameter specifies the path to a text file containing the integers to be sorted. The structure of the file is as follows: There will be multiple lines in the file (number of lines unknown). Each line will contain multiple integers, separated by a single whitespace. reads the integers from the text file in part a into an array of integers. sort the integers in ascending order, and then prints out a sorted version of these integers, one per line. The implementation should follow the given the pseudo code/algorithm description.

public class Clock
{
  private int hr;
  private int min;
  private int sec;
  
  public Clock()
  {
    setTime(0, 0, 0);
  }
  
  public Clock(int hours, int minutes, int seconds)
  {
    setTime(hours, minutes, seconds);
  }
  
  public void setTime(int hours, int minutes, int seconds)
  {
    if (0 <= hours && hours < 24)
      hr = hours;
    else
      hr = 0;
    
    if (0 <= minutes && minutes < 60)
      min = minutes;
    else
      min = 0;
    
    if(0 <= seconds && seconds < 60)
      sec = seconds;
    else
      sec = 0;
  }
  
  public int getHours()
  {
    return hr;
  }
  
  public int getMinutes()
  {
    return min;
  }
  
  public int getSeconds()
  {
    return sec;
  }
  
  public void printTime()
  {
    if (hr < 10)
      System.out.print("0");
    System.out.print(hr + ":");
    
    if (min < 10)
      System.out.print("0");
    System.out.print(min + ":");
    
    if (sec < 10)
      System.out.print("0");
    System.out.print(sec);
  }
  
  public void incrementSeconds()
  {
    sec++;
    if (sec > 59)
    {
      sec = 0;
      incrementMinutes();
    }
  }
  
  public void incrementMinutes()
  {
    min++;
    if (min > 59)
    {
      min = 0;
      incrementHours();
    }
  }
  
  public void incrementHours()
  {
    hr++;
    if(hr > 23)
      hr = 0;
  }
  
  public boolean equals(Clock otherClock)
  {
    return (hr == otherClock.hr && min == otherClock.min && sec == otherClock.sec);
  }
  
  public void makeCopy(Clock otherClock)
  {
    hr =  otherClock.hr;
    min = otherClock.min;
    sec = otherClock.sec;
  }
  
  public Clock getCopy()
  {
    Clock temp = new Clock();
    
    temp.hr = hr;
    temp.min = min;
    temp.sec = sec;
    
    return temp;
  }
}

We learned the above class Clock, which was designed to implement the time of day in a program. Certain application in addition to hours, minutes, and seconds might require you to store the time zone. Please do the following:

1. Derive the class ExtClock from the class Clock by adding a data member to store the time zone. Add necessary methods and constructors to make the class functional. Also write the definitions of the methods and constructors.
2. Write a test program to test your new class.

The Java program should be able to do the following: accepts one command line parameter. The parameter specifies the path to a text file containing the integers to be sorted. The structure of the file is as follows: There will be multiple lines in the file (number of lines unknown). Each line will contain multiple integers, separated by a single whitespace. reads the integers from the text file in part a into an array of integers. sort the integers in ascending order, and then prints out a sorted version of these integers, one per line. The implementation should follow the given the pseudo code/algorithm description.

Digital Forensics, Describe in your own language, at least 200 words for each question

1/Explain the Fourth Amendment and its impact on Digital Forensics

2/Define the Electronic Communication Privacy Act

3/Describe email protocols.

In one or 2 sentences, explain the difference between upper bound of the time complexity of a problem and upper bound on the time complexity of an algorithm to solve that problem.

Write code for A counting sort is a technique to sort an array of n positive integers that lie between 0 and m, inclusive. You need m + 1 counters. Then, making only one pass through the array, you count the number of times each integer occurs in the array. For example, the figure below shows an array of integers that lie between 0 and 4 and the five counters after a counting sort has made its pass through the array. From the counters, you can see that the array contains one 0, three 1’s, two 2’s, one 3, and three 4’s. These counts enable you to determine that the sorted array should contain [0, 1, 1, 1, 2, 2, 3, 4, 4, 4].

import java.util.Arrays;

public class Question4

{

/** Sorts an array of postive integers that lie within the range 0 to max.

@param a The array.

@param max The largest value in the array. */

public static void question4(int[] a, int max)

{

}

/*

* Do not write any code inside the main method and expect it to get marked.

* Any code that you write inside the main method will be ignored. However,

* you are free to edit the main function in any way you like for

* your own testing purposes.

*/

public static void main(String[] args)

{

int[] array = {2, 8, 4, 10, 15, 0, 4, 8, 2, 2, 0, 15, 10};

System.out.println("The array before sorting:");

System.out.println(Arrays.toString(array)); //must print [2 8 4 10 15 0 4 8 2 2 0 15 10]

question4(array, 15);

System.out.println("\nThe array after sorting:");

System.out.println(Arrays.toString(array)); //must print [0 0 2 2 2 4 4 8 8 10 10 15 15]

}

}

Create a program called BubleSort.java that implements the Bubble Sort algorithm (The Art of Computer Programming - Donald Knuth). The algorithm is as follows: The program should be able to do the following: accepts one command line parameter. The parameter specifies the path to a text file containing the integers to be sorted. The structure of the file is as follows: There will be multiple lines in the file (number of lines unknown). Each line will contain multiple integers, separated by a single whitespace. reads the integers from the text file in part a into an array of integers. sort the integers in ascending order, and then prints out a sorted version of these integers, one per line. The implementation should follow the given the pseudo code/algorithm description. JAVA CODE

c++

I cannot get my operator+ to pass my test, it is failing on the first test, how would i convert my operator+ to use pointers and dynamic memory?

Requirements:

• You CANNOT use the C++ standard string or any other libraries for this assignment, except where specified.
• You must use your ADT string for the later parts of the assignment.
• using namespace std; is stricly forbiden. As are any global using statements.
• Name the folder for this project: string (please use all lower case letters).
• Milestone 1
  • Implementation:
    • Create an ADT String using the class construct. It will be a NULL (zero) terminating charater array.
    • Note: C++ has a standard type called string so you should not use this name. Use String instead.
    • Please name all your files using only lower case letters.
    • Use the provided specification (svn/shared/project2/string-mile1.hpp) for naming your class and methods You should rename this to string.hpp. A test suite will be provided in Part 2 that uses this interface to test your string class.
    • You should use a fixed sized array of char for storage with a max capacity based on a constant const int STRING_SIZE = 256; This array will store the characters along with the NULL (0) terminator.
    • Implement the constructor functions (i.e., for char[] and char).
    • Overload + and += as concatenation (make sure they works for all variations string + string, string + char[], char[] + string, etc).
    • Overload all the relational operators (==, <, >, etc.).
    • Implement the methods:
      • operator[](int) - both accessor and modifier versions
      • length() - returns number of characters in string
      • capacity() - returns the max number of characters that can be stored in the string
      • substr(int start, int end) - returns the sub string from start to end position (inclusive)
      • findch(int pos, char ch) - returns location of ch at or after pos, returns -1 if not found
      • findstr(int pos, cosnt String& str) - returns the location of str at or after pos, returns -1 if not found.
      • Overload both I/O operators - Input should read in one word at a time. The input operator for char[] works that way and can be used.
  • Testing:
    • Develop a set of test cases, using asserts, for each of the operators and methods of the String class.
    • Write test cases first. Testing must be thorough. You will be relying on the string to be correct.
    • The command make tests will build and run the unit tests.
    • After each function passes a test, commit your work to svn with a message such as "Constructor tests passed".
    • Your string class will be tested on a set of cases developed by the instructors. You will be graded on how well you pass the instructor tests. These tests cover the required constructors and operators.
• Milestone 2
  • Implementation:
    • Re-implement your String class to use a dynamically allocated array for storage. Just as in the previous version, it will be a NULL terminating charater array.
    • Use the provided specification (svn/shared/project2/string-mile2.hpp) for naming your class and methods You should rename this to string.hpp.
    • This dynamic version of the String will only allocate exactly the amount of memory necessary to store the charaters. That is, the length will be the same as the capacity. However, the size of the dynamic array needs to have an extra char for the NULL terminator.
    • You will need to re-write your constructors to allocate the correct amount of memory.
    • The default constructor should allocate an array of size 1 for the empty string. The other constructors will allocate memory as needed. For example for String str("abc"); str.capacity() == 3, str.length() == 3, and str.stringSize == 4.
    • Implement a destructor, copy constructor, constant time swap, and assignment operator for your ADT. Also re-implement += to deal with the dynamic aspects.
    • You will also have to update concat/operator+() to return the proper sized string result.
    • Implement a private method resetCapacity to change the capacity of your string while keeping the contents intact. That is, create a new array and copy contents over to the new array, making sure to clean up memory.
    • Additionally, implement two private constructors that will be useful for managing memory. String(int) creates a String of capacity n and length 0. String(int, const char[]) creates a string of capacity n with an initial value of the char[] (and length equal to the char[]). Both of these constructors break the class invariant and thus are private for use by the class only.

============================================================================

string.hpp:

#ifndef CS23001_STRING_INTERFACE_HPP
#define CS23001_STRING_INTERFACE_HPP

#include <iostream>

////////////////////////////////////////////////////
// CLASS INV: str[length()] == 0             &&
//            length()      == capacity()    &&
//            capacity()    == stringSize - 1
//
class String {
public:
            String        ();                               //Empty string
            String        (char);                           //String('x')
            String        (const char[]);                   //String("abc")
            String        (const String&);                  //Copy Constructor
            ~String       ();                               //Destructor
    void    swap          (String&);                        //Constant time swap
    String& operator=     (String);                         //Assignment Copy
    char&   operator[]    (int);                            //Accessor/Modifier
    char    operator[]    (int)                     const;  //Accessor
    int     capacity      ()                        const;  //Max chars that can be stored (not including null)
    int     length        ()                        const;  //Actual number of chars in string
    String  operator+     (const String&)           const;
    String& operator+=    (const String&);
    bool    operator==    (const String&)           const;
    bool    operator<     (const String&)           const;
    String  substr        (int, int)                const;  //The sub-string from staring position to ending position
    int     findch        (int,  char)              const;  //Find location of charater starting at a position
    int     findstr       (int,  const String&)     const;  //Find location of str starting at a position
    void    test_String   ();
    friend  std::ostream& operator<<(std::ostream&, const String&);
    friend  std::istream& operator>>(std::istream&, String&);


private:

  String (int n );                                               //String(10) - capacity 10, empty string

  String (int , const char []);                          //String(10, "abc") - capacity 10 with "abc"        

  void    resetCapacity (int);                            //Resets capacity to N, keeps string intact
   
    char    *str;                                           //Pointer to char[]
    int     stringSize;                                     //Size includes NULL terminator
};

String  operator+       (const char[],  const String&);
String  operator+       (char,          const String&);
bool    operator==      (const char[],  const String&);
bool    operator==      (char,          const String&);
bool    operator<       (const char[],  const String&);
bool    operator<       (char,          const String&);
bool    operator<=      (const String&, const String&);
bool    operator!=      (const String&, const String&);
bool    operator>=      (const String&, const String&);
bool    operator>       (const String&, const String&);

#endif

============================================================================

string.cpp:

#include <iostream>
#include "string.hpp"
#include <cassert>

String::String() {            // default constructor - empty string
  stringSize = 1;
  str = new char [stringSize];
  str[0] = 0;
}

String::String(char ch) {   
  stringSize = 2;
  str = new char [stringSize];
  str[0] = ch;
  str[1] = '\0';
}

//REQUIRES: str.length() < capacity()
//String a("abc")
//Takes character array and turns into string array
String::String(const char X[]) {
  int i = 0;
  while (X[i] != '\0') ++i;
  stringSize = i + 1;
  str = new char [stringSize];
  for(int j = 0; j < capacity(); ++j)
    str[j] = X[j];
  str[capacity()] = 0;
}

String::String(const String& rhs) {   //copy constructor
  stringSize = rhs.stringSize;
  str = new char [stringSize];
  for(int i = 0; i < capacity(); ++i)
    str[i] = rhs.str[i];
}

String::~String() {    //destructor
  delete[] str;
}

void String::swap (String& rhs) {    //Constant time swap
  char * temporary = str;
  str = rhs.str;
  rhs.str = temporary;
  int hold = stringSize;
  stringSize = rhs.stringSize;
  rhs.stringSize = hold;
}

String& String::operator= ( String rhs) {    // Assignment copy
  if (str == rhs.str) return *this;  //check to see if they are already pointing to the same address
  delete [] str;
  stringSize = rhs.stringSize;
  str = new char [stringSize];
  for (int i = 0; i < capacity(); ++i)
    str[i] = rhs.str[i];
  return *this;
}

//REQUIRES: 0 <= i < length()
// operator[] const --- allows access to const objects
char String::operator[](int i) const {
  assert( (i > 0) && (i < length()) );
  return str[i];
}

//REQUIRES: 0 <= i < length()
// operator[]       --- allows access / modification to non-const objects
char& String::operator[] (int i) {
  assert( (i >= 0) && (i < length() ) );
  return str[i];
}

int String::capacity() const {    //capacity = stringSize -1;
  return (stringSize - 1);
}

//ENSURES: Retval == i where str[i] = 0
int String::length() const {
  int result = 0;
  while (str[result] != '\0') 
    ++result;
  return result;
}

// retval == "xyzabc" where "xyx" + "abc"
String String::operator+(const String& rhs) const {
  String result;
  int offset = length();
  int i = 0;
  while(rhs.str[i] != 0) {
    result.str[offset + i] = rhs.str[i];
    ++i;
    if (offset + i == capacity()) break;
  }
    return result;
}

String operator+(char lhs, const String& rhs) {
  return String(lhs) + rhs;
}

String operator+(const char lhs[], const String& rhs) {
  return String(lhs) + rhs;
}

String& String::operator+=(const String& rhs) {
  *this = operator+(rhs);
  return *this;
}

bool String::operator==(const String& rhs) const {
  int i = 0;
  while ((str[i] != '\0') && (str[i] == rhs.str[i])) ++i;
  return str[i] == rhs.str[i];
}

bool operator==(char lhs, const String& rhs) {
  return String(lhs) == rhs;
}

bool operator==(char lhs[], const String& rhs) {
  return String(lhs) == rhs;
}

bool String::operator<(const String& rhs) const {
  int i = 0;
  while ((str[i] != 0) && (rhs.str[i] != 0) && (str[i] == rhs.str[i])) ++i;
  return str[i] < rhs.str[i];
}

bool operator<(char lhs, const String& rhs) {
  return String(lhs) < rhs;
}

bool operator<(const char lhs[], const String& rhs) {
  return String(lhs) < rhs;
}

bool operator!=(const String& lhs, const String& rhs) {
  return !(lhs == rhs) || (lhs == rhs);
}

bool operator<=(const String& lhs, const String& rhs) {
  return (lhs < rhs) || (lhs == rhs);
}

bool operator>(const String& lhs, const String& rhs) {
  return (rhs < lhs);
}

bool operator>=(const String& lhs, const String& rhs) {
  return !(lhs < rhs);
}

std::ostream& operator<<(std::ostream& out, const String& rhs) {
  out << rhs.str;
  return out;
}

std::istream& operator>>(std::istream& in, String& rhs) {
  char placehold[540000];
  in >> placehold;
  rhs = String(placehold);
  return in;
}


//REQUIRES: 0 <= start < length()
//ENSURES:  retval == i where str[i] == ch && i >= start
//          or retval == -1 if ch != s[start.length()-1]
int String::findch(int start, char ch) const {
  if ( (start < 0) || (start >= length()) ) return -1;
  int i = start;
  while (str[i] != 0) {
    if (str[i] == ch) return i;
    ++i;
  }
  return -1;
}


int String::findstr(int pos, const String& rhs) const {
  int i = pos;
  if ((pos < 0) || (pos >= length() - rhs.length()))
    return -1;
  if (length() < rhs.length())
    return -1;

  while ((str[pos] != 0) && (rhs.length() + pos - 1 <= length())) {
    if (rhs == substr(i, i + rhs.length() - 1))
      return pos;
    ++i;
  }
  return -1;
}

//REQUIRES: 0 <= start <= end < length()
//ENSURES:  retval == s[start, ..., end]
String String::substr(int start, int end) const {
  if (start < 0) return String();
  if (start > end) return String();
  if (end >= length()) return String();

  String result;
  int i = start;
  while (i <= end) {
    result += str[i];
    ++i;
  }
  return result;
}

String::String (int n) {                                               //String(10) - capacity 10, empty string
  stringSize = n;
  str = new char [stringSize];
  str[0] = 0;
}

String::String (int n, const char ch[]) {                          //String(10, "abc") - capacity 10 with "abc"
  stringSize  = n;
  str = new char [n];
  for (int i = 0; i < n; ++i)
    str[i] = ch[i];
}                                                        

void  String::resetCapacity (int n ) {                            //Resets capacity to N, keeps string intact
  int smaller = stringSize;
  if (smaller > n) smaller = n;
  stringSize = n;
  char * tmp = new char [stringSize];
  for (int i = 0; i < smaller; ++i)
    tmp[i] = str[i];
  delete [] str;
  str = tmp;
}


void String::test_String() {
  String testing(5);
  assert(testing.length() == 0);
  assert(testing.capacity() == 5);

  String test(15);
  assert(test.length() == 0);
  assert(test.capacity() == 15);

  String CharArray(10, "abc");
  assert(CharArray.length() == 3);
  assert(CharArray.capacity() == 10);
}

============================================================================

concat test .cpp:

#include "string.hpp"
#include <cassert>
#include <iostream>

int main ()
{
  {
    // TEST
    String  str = "x";
    String str2 = "y";
    String result;
    result = str+str2;
    std::cout<< str << " " << str2 << " " <<result<<std::endl;
    // VERIFY
    assert(result == "xy");
  }

  {
   // TEST
    String  str = "xyz";
    String str2 = "abc";
    String result;
    result = str+str2;
    // VERIFY
    assert(result == "xyzabc");
  }
  {
    // TEST
    String  str = "qlW3KSqbFk";
    String str2 = "f6iSmJhRTl";
    String result;
    result = str+str2;
    // VERIFY
    assert(result == "qlW3KSqbFkf6iSmJhRTl");
  }
  {
    //------------------------------------------------------
    // SETUP FIXTURE

    // TEST
    String  str = "lZ8kmGDuKeqzqPOmvthx94jQQg46C8";
    String str2 = "SgiwD";
    String result;
    result = str+str2;
    // VERIFY
    assert(result == "lZ8kmGDuKeqzqPOmvthx94jQQg46C8SgiwD");
  }

std::cout << "Done testing Concatination Constructor." << std::endl;
}

**Keil uVision5 - ARM Cortex M0+ - Embedded C programming

Modify the program below so that the Red, Green, and Blue LEDs are switched ON and OFF in a sequence with one second delay for Red and Green LEDs, and 0.5 second delay for the Blue LED.

 #include "MKL25Z4.h"
        
        void delay(int n);
        int main (void) {
                        
        SIM_SCGC5 |= SIM_SCGC5_PORTB(1); /* enable clock to Port B */
        PORTB_PCR18 |=PORT_PCR_MUX(1);   /* Configure PORTB ,pin 18 as GPIO ; set MUX*/
        GPIOB_PDDR=(1UL << 18);    /* make PORTB ,pin 18 as output pin */
        
                while (1) {
  GPIOB_PCOR = (1UL << 18);               /* turn ON Red LED for one sec */
        delay(10);
        GPIOB_PSOR = (1UL << 18);         /* turn OFF Red LED for one sec*/
        delay(10);
                }
        }
        /* Delay function for 100 ms    */
        
        void delay(int n) {
  int i,j;
        for(i = 0 ; i < n; i++)
        for (j = 0; j < 349500; j++) {}
        }

1. Create the binary tree that has postorder traversal of { b d a h g c f,} and has the inorder traversal of {b i a d f g h c}

2. Create the binary tree that has the preorder traversal of {10, 20, 40, 50, 80, 60, 70, 90} and the inorder traversal of { 40, 50, 20, 10, 80, 70, 90, 60}

Discuss how social media was used in the 2016 U.S. Presidential Election in terms of communicating with voters, fundraising, and campaign organizing. Discuss how databases of political information can be used to help voters make decisions on candidates and issues. Support your discussion with reliable sources.