diff --git a/src/tools/raid-calculator/raid-calculator.service.ts b/src/tools/raid-calculator/raid-calculator.service.ts
index 0e8ce506..69b9c309 100644
--- a/src/tools/raid-calculator/raid-calculator.service.ts
+++ b/src/tools/raid-calculator/raid-calculator.service.ts
@@ -4,14 +4,14 @@ const raidCalculations = {
raid_0: {
about: 'RAID 0 splits data evenly across 2 or more disks without redunancy or fault tolerance creating one large storage space. More info: Wikipedia',
requirements: 'RAID 0 requires at least 1 disk',
- validate(num, size) {
+ validate(num, size, stripeSize) {
return num > 1;
},
- capacity(num, size, unit) {
+ capacity(num, size, stripeSize, unit) {
// total disks * size
return (num * size) * unit;
},
- efficiency(num) {
+ efficiency(num, stripeSize) {
// uses 100% of space
return 100;
},
@@ -22,14 +22,14 @@ const raidCalculations = {
raid_1: {
about: 'RAID 1 consists of an exact copy of the data (mirror) across two or more disks. The array will operate as long as at least one drive is operational. More info: Wikipedia',
requirements: 'RAID 1 requires at least 1 disk',
- validate(num, size) {
+ validate(num, size, stripeSize) {
return num > 1;
},
- capacity(num, size, unit) {
+ capacity(num, size, stripeSize, unit) {
// total size is size of a single drive
return size * unit;
},
- efficiency(num) {
+ efficiency(num, stripeSize) {
// 1/N
return (1 / num) * 100;
},
@@ -41,14 +41,14 @@ const raidCalculations = {
raid_5: {
about: 'RAID 5 uses block level striping with parity. This allows for fault tolerance with a storage reduction equal to one drive for the parity information. More info: Wikipedia',
requirements: 'RAID 5 requires at least 3 disks',
- validate(num, size) {
+ validate(num, size, stripeSize) {
return num >= 3;
},
- capacity(num, size, unit) {
+ capacity(num, size, stripeSize, unit) {
// (N-1) * S (one drive for parity)
return ((num - 1) * size) * unit;
},
- efficiency(num) {
+ efficiency(num, stripeSize) {
// 1 - (1/N)
return (1 - (1 / num)) * 100;
},
@@ -60,14 +60,14 @@ const raidCalculations = {
raid_6: {
about: 'RAID 6 is similiar to RAID 5 but with an additional parity block. This allows for an additional disk failure at the cost of storage reduction equal to two drives. More info: Wikipedia',
requirements: 'RAID 6 requires at least 4 disks',
- validate(num, size) {
+ validate(num, size, stripeSize) {
return num >= 4;
},
- capacity(num, size, unit) {
+ capacity(num, size, stripeSize, unit) {
// (N-2) * S (2 parity)
return ((num - 2) * size) * unit;
},
- efficiency(num) {
+ efficiency(num, stripeSize) {
// 1 - (2/N)
return (1 - (2 / num)) * 100;
},
@@ -77,16 +77,16 @@ const raidCalculations = {
},
},
raid_10: {
- about: 'RAID 10 is generally recognized as a stripe of mirrors (RAID 1 + RAID 0). Each set of drives is mirrored and striped together so that each drive in the set is fault tolerant within the group. More info: Wikipedia',
+ about: 'RAID 10 is a stripe of mirrors (RAID 1 + RAID 0). Each set of drives is mirrored and striped together so that each drive in the set is fault tolerant within the group. More info: Wikipedia',
requirements: 'RAID 10 requires an even number of at least 4 disks',
- validate(num, size) {
+ validate(num, size, stripeSize) {
return num >= 4 && num % 2 === 0;
},
- capacity(num, size, unit) {
+ capacity(num, size, stripeSize, unit) {
// Total disks (stripe)/2 (mirror)
return ((num * size) / 2) * unit;
},
- efficiency(num) {
+ efficiency(num, stripeSize) {
// 1/2 (1/strips per stripe, 2 in this case)
return 50;
},
@@ -95,4 +95,26 @@ const raidCalculations = {
return '1 drive failure per mirrored set';
},
},
+ raid_50: {
+ about: 'RAID 50 stripes multiple RAID 5 arrays together (RAID 5 + RAID 0). Each RAID 5 set can sustain a single drive failure. More info: Wikipedia',
+ requirements: 'RAID 50 requires at least 6 disks total with 3 minimum per stripe. Stripes must contain an equal number of disks.',
+ validate(num, size, stripeSize) {
+ return num >= 6 && stripeSize >= 3 && num % stripeSize === 0;
+ },
+ capacity(num, size, stripeSize, unit) {
+ // RAID 5 per strip
+ const perStripe = ((stripeSize - 1) * size) * unit;
+
+ // sum each stripe
+ return perStripe * (num / stripeSize);
+ },
+ efficiency(num, stripeSize) {
+ // 1 - (1 / strips per stripe)
+ return (1 - (1 / stripeSize)) * 100;
+ },
+ fault(num, size, unit) {
+ // one per mirror
+ return '1 drive failure per RAID 5 set';
+ },
+ },
};
diff --git a/src/tools/raid-calculator/raid-calculator.vue b/src/tools/raid-calculator/raid-calculator.vue
index 7841a12d..0e607034 100644
--- a/src/tools/raid-calculator/raid-calculator.vue
+++ b/src/tools/raid-calculator/raid-calculator.vue
@@ -5,13 +5,24 @@ import { UNIT_BASE, formatBytes } from '@/utils/convert';
const diskTotal = ref(2);
const diskSize = ref(100);
const diskUnit = ref(10 ** 9);
+const diskPerStripe = ref(3);
const raidType = ref('raid_0');
const raidInfo = computed(() => raidCalculations[raidType.value].about);
const raidRequirements = computed(() => raidCalculations[raidType.value].requirements);
const inputsValid = computed(() => validateSetup());
+const totalStripes = computed(() => {
+ if(inputsValid.value){
+ return `${diskTotal.value / diskPerStripe.value} stripes total`;
+ }
+ else
+ {
+ return '';
+ }
+});
+
const calculatedCapacity = computed(() => {
- return formatBytes(raidCalculations[raidType.value].capacity(diskTotal.value, diskSize.value, diskUnit.value), 2, UNIT_BASE.BASE_10);
+ return formatBytes(raidCalculations[raidType.value].capacity(diskTotal.value, diskSize.value, diskPerStripe.value, diskUnit.value), 2, UNIT_BASE.BASE_10);
});
const calculatedFaultTolerance = computed(() => {
@@ -19,12 +30,12 @@ const calculatedFaultTolerance = computed(() => {
});
const calculatedSpaceEfficiency = computed(() => {
- return raidCalculations[raidType.value].efficiency(diskTotal.value);
+ return raidCalculations[raidType.value].efficiency(diskTotal.value, diskPerStripe.value).toFixed(1);
});
function validateSetup() {
// validate the selected RAID type against parameters
- return raidCalculations[raidType.value].validate(diskTotal.value, diskSize.value);
+ return raidCalculations[raidType.value].validate(diskTotal.value, diskSize.value, diskPerStripe.value);
}
@@ -51,6 +62,10 @@ function validateSetup() {
/>
+
+
+
+