Simulation of RAID Levels Gaming Project in C++

Projects Inventory

3 months ago

#include <iostream>
#include <vector>
#include <string>

enum RaidLevel { RAID0, RAID1, NUM_RAID_LEVELS };

class RAID {
public:
    virtual void writeData(const std::string& data) = 0;
    virtual std::string readData() const = 0;
    virtual ~RAID() = default;
};

class RAID0 : public RAID {
public:
    RAID0(int numDisks) : numDisks(numDisks) {
        disks.resize(numDisks);
    }

    void writeData(const std::string& data) override {
        for (int i = 0; i < numDisks; ++i) {
            disks[i] = data.substr(i * (data.size() / numDisks), data.size() / numDisks);
        }
    }

    std::string readData() const override {
        std::string result;
        for (const auto& disk : disks) {
            result += disk;
        }
        return result;
    }

private:
    int numDisks;
    std::vector<std::string> disks;
};

class RAID1 : public RAID {
public:
    RAID1(int numDisks) : numDisks(numDisks) {
        disks.resize(numDisks);
    }

    void writeData(const std::string& data) override {
        // Write to the first disk and mirror it to others
        disks[0] = data;
        for (int i = 1; i < numDisks; ++i) {
            disks[i] = disks[0];
        }
    }

    std::string readData() const override {
        // Data from the first disk (mirrored)
        return disks[0];
    }

private:
    int numDisks;
    std::vector<std::string> disks;
};

void simulateRaid(RaidLevel level, const std::string& data) {
    std::unique_ptr<RAID> raid;
    if (level == RAID0) {
        raid = std::make_unique<RAID0>(2); // Example with 2 disks
    } else if (level == RAID1) {
        raid = std::make_unique<RAID1>(2); // Example with 2 disks
    }

    if (raid) {
        raid->writeData(data);
        std::cout << "Read data from RAID level " << level << ": " << raid->readData() << "\n";
    }
}

int main() {
    std::string data = "This is sample data for RAID simulation.";

    std::cout << "Simulating RAID 0:\n";
    simulateRaid(RAID0, data);

    std::cout << "Simulating RAID 1:\n";
    simulateRaid(RAID1, data);

    return 0;
}

#include <iostream>

#include <vector>

#include <string>

enum RaidLevel { RAID0, RAID1, NUM_RAID_LEVELS };

class RAID {

public:

virtual void writeData(const std::string& data) = 0;

virtual std::string readData() const = 0;

virtual ~RAID() = default;

};

class RAID0 : public RAID {

public:

RAID0(int numDisks) : numDisks(numDisks) {

disks.resize(numDisks);

}

void writeData(const std::string& data) override {

for (int i = 0; i < numDisks; ++i) {

disks[i] = data.substr(i * (data.size() / numDisks), data.size() / numDisks);

}

std::string readData() const override {

std::string result;

for (const auto& disk : disks) {

result += disk;

}

return result;

}

private:

int numDisks;

std::vector<std::string> disks;

};

class RAID1 : public RAID {

public:

RAID1(int numDisks) : numDisks(numDisks) {

disks.resize(numDisks);

}

void writeData(const std::string& data) override {

// Write to the first disk and mirror it to others

disks[0] = data;

for (int i = 1; i < numDisks; ++i) {

disks[i] = disks[0];

}

std::string readData() const override {

// Data from the first disk (mirrored)

return disks[0];

}

private:

int numDisks;

std::vector<std::string> disks;

};

void simulateRaid(RaidLevel level, const std::string& data) {

std::unique_ptr<RAID> raid;

if (level == RAID0) {

raid = std::make_unique<RAID0>(2); // Example with 2 disks

} else if (level == RAID1) {

raid = std::make_unique<RAID1>(2); // Example with 2 disks

}

if (raid) {

raid->writeData(data);

std::cout << "Read data from RAID level " << level << ": " << raid->readData() << "\n";

}

int main() {

std::string data = "This is sample data for RAID simulation.";

std::cout << "Simulating RAID 0:\n";

simulateRaid(RAID0, data);

std::cout << "Simulating RAID 1:\n";

simulateRaid(RAID1, data);

return 0;

}

Explanation

Enums:
- RaidLevel: Enum representing different RAID levels (RAID 0, RAID 1).
Class RAID:
- Purpose: Abstract base class for RAID implementations.
- Methods:
  - writeData(const std::string& data): Pure virtual method for writing data.
  - readData() const: Pure virtual method for reading data.
- Destructor: Virtual destructor to ensure proper cleanup of derived classes.
Class RAID0:
- Purpose: Implements RAID 0 (striping) which splits data across multiple disks.
- Methods:
  - writeData(const std::string& data)
    
    Advertisement
    
    : Splits the data evenly across the disks.
  - readData() const: Concatenates the data from all disks.
- Attributes:
  - numDisks: Number of disks in the RAID array.
  - disks: Vector to store the data for each disk.
Class RAID1:
- Purpose: Implements RAID 1 (mirroring) which duplicates data across all disks.
- Methods:
  - writeData(const std::string& data): Writes data to the first disk and mirrors it to others.
  - readData() const: Reads data from the first disk.
- Attributes:
  - numDisks: Number of disks in the RAID array.
  - disks: Vector to store the data for each disk.
Function simulateRaid(RaidLevel level, const std::string& data):
- Purpose: Simulates RAID level operations.
- Parameters:
  - level: RAID level to simulate (RAID 0 or RAID 1).
  - data: Data to write and read from the RAID array.
- Implementation:
  - Creates an instance of the appropriate RAID class.
  - Writes and reads data using the RAID instance.
  - Outputs the result.
Main Function:
- Setup: Defines sample data to use in the simulation.
- Simulation:
  - Simulates RAID 0 and RAID 1 by calling simulateRaid with the data.

Usage

RAID Simulation: Demonstrates basic operations of RAID 0 (striping) and RAID 1 (mirroring).
Data Handling: Shows how data is managed and retrieved in different RAID configurations.

Explanation

Usage

Related Posts: