From 8bb3534b317b5be2ecdf636d01a037753f2caae2 Mon Sep 17 00:00:00 2001 From: Rob Weber Date: Tue, 30 Jul 2024 14:37:45 +0000 Subject: [PATCH] added raid 50 --- .../raid-calculator.service.ts | 54 +++++++++++++------ src/tools/raid-calculator/raid-calculator.vue | 22 ++++++-- 2 files changed, 57 insertions(+), 19 deletions(-) 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() { /> + + + +