What is the minimum number of disks in raid 0. What is RAID in the physical sense

The shift in focus from processor-centric to data-centric applications is driving the increased importance of data storage systems. At the same time, the problem of low throughput and fault tolerance characteristic of such systems has always been quite important and always required a solution.

In modern computer industry Magnetic disks are widely used as a secondary data storage system, because, despite all their shortcomings, they have the best characteristics for the corresponding type of device at an affordable price.

Features of the technology for constructing magnetic disks have led to a significant discrepancy between the increase in performance of processor modules and the magnetic disks themselves. If in 1990 the best among serial ones were 5.25″ drives with an average access time of 12 ms and a latency time of 5 ms (at a spindle speed of about 5,000 rpm 1), then today the palm belongs to 3.5″ drives with an average access time of 5 ms and delay time 1 ms (at spindle speed 10,000 rpm). Here we see an improvement in technical characteristics of about 100%. At the same time, processor performance increased by more than 2,000%. This is largely possible because the processors have the direct benefits of using VLSI (Very Large Scale Integration). Its use not only makes it possible to increase the frequency, but also the number of components that can be integrated into the chip, which makes it possible to introduce architectural advantages that allow parallel computing.

1 - Average data.

The current situation can be characterized as a secondary storage system I/O crisis.

Increasing performance

The impossibility of significantly increasing the technological parameters of magnetic disks entails the need to search for other ways, one of which is parallel processing.

If you arrange a block of data across N disks of some array and organize this placement so that it is possible to read information simultaneously, then this block can be read N times faster (without taking into account the block formation time). Since all data is transferred in parallel, this architectural solution is called parallel-access array(array with parallel access).

Parallel arrays are typically used for applications that require large data transfers.

Some tasks, on the contrary, are characterized by a large number of small requests. Such tasks include, for example, database processing tasks. By distributing database records across array disks, you can distribute the load by positioning the disks independently. This architecture is usually called independent-access array(array with independent access).

Increasing fault tolerance

Unfortunately, as the number of disks in an array increases, the reliability of the entire array decreases. With independent failures and an exponential distribution law of time between failures, the MTTF of the entire array (mean time to failure) is calculated using the formula MTTF array = MMTF hdd /N hdd (MMTF hdd is the mean time to failure of one disk; NHDD is the number disks).

Thus, there is a need to increase the fault tolerance of disk arrays. To increase the fault tolerance of arrays, redundant coding is used. There are two main types of encoding that are used in redundant disk arrays - duplication and parity.

Duplication, or mirroring, is most often used in disk arrays. Simple mirror systems use two copies of data, each copy located on separate disks. This circuit is quite simple and does not require additional hardware costs, but has one significant drawback- it uses 50% of disk space to store a copy of information.

The second way to implement redundant disk arrays is to use redundant encoding using parity calculation. Parity is calculated by XORing all the characters in the data word. Using parity in redundant disk arrays reduces overhead to a value calculated by the formula: HP hdd =1/N hdd (HP hdd - overhead; N hdd - number of disks in the array).

History and development of RAID

Although storage systems based on magnetic disks, have been produced for 40 years; mass production of fault-tolerant systems began quite recently. Redundant disk arrays, commonly called RAID (redundant arrays of inexpensive disks), were introduced by researchers (Petterson, Gibson and Katz) at the University of California, Berkeley in 1987. But RAID systems became widespread only when disks that were suitable for use in redundant arrays became available and sufficiently productive. Since the white paper on RAID in 1988, research into redundant disk arrays has exploded in an attempt to provide a wide range of cost-performance-reliability trade-offs.

There was an incident with the abbreviation RAID at one time. The fact is that at the time of writing this article, all disks that were used in PCs were called inexpensive disks, as opposed to expensive disks for mainframes (mainframe computers). But for use in RAID arrays, it was necessary to use quite expensive equipment compared to other PC configurations, so RAID began to be deciphered as redundant array of independent disks 2 - a redundant array of independent disks.

2 - Definition of RAID Advisory Board

RAID 0 was introduced by the industry as the definition of a non-fault-tolerant disk array. Berkeley defined RAID 1 as a mirrored disk array. RAID 2 is reserved for arrays that use Hamming code. RAID levels 3, 4, 5 use parity to protect data from single faults. It was these levels, including level 5, that were presented at Berkeley, and this RAID taxonomy was adopted as a de facto standard.

RAID levels 3,4,5 are quite popular and have good disk space utilization, but they have one significant drawback - they are only resistant to single faults. This is especially true when using a large number of disks, when the likelihood of simultaneous downtime of more than one device increases. In addition, they are characterized by a long recovery, which also imposes some restrictions on their use.

Today, a fairly large number of architectures have been developed that ensure the operation of the array even with the simultaneous failure of any two disks without data loss. Among the whole set, it is worth noting two-dimensional parity and EVENODD, which use parity for encoding, and RAID 6, which uses Reed-Solomon encoding.

In a scheme using dual-space parity, each data block participates in the construction of two independent codewords. Thus, if a second disk in the same codeword fails, a different codeword is used to reconstruct the data.

The minimum redundancy in such an array is achieved with an equal number of columns and rows. And is equal to: 2 x Square (N Disk) (in “square”).

If the two-space array is not organized into a “square,” then when implementing the above scheme, the redundancy will be higher.

The EVENODD architecture has a fault tolerance scheme similar to dual-space parity, but a different placement of information blocks that guarantees minimal redundant capacity utilization. As in dual-space parity, each data block participates in the construction of two independent codewords, but the words are placed in such a way that the redundancy coefficient is constant (unlike the previous scheme) and is equal to: 2 x Square (N Disk).

By using two check characters, parity and non-binary codes, the data word can be designed to provide fault tolerance when a double fault occurs. This design is known as RAID 6. Non-binary code, built on top of Reed-Solomon coding, is typically computed using tables or as an iterative process using linear registers with feedback, which is a relatively complex operation requiring specialized hardware.

Considering that the use of classic RAID options, which provide sufficient fault tolerance for many applications, often has unacceptably low performance, researchers from time to time implement various moves that help increase the performance of RAID systems.

In 1996, Savage and Wilks proposed AFRAID - A Frequently Redundant Array of Independent Disks. This architecture to some extent sacrifices fault tolerance for performance. In an attempt to compensate for the small-write problem typical of RAID level 5 arrays, it is possible to leave striping without parity calculation for a certain period of time. If the disk designated for parity recording is busy, parity recording is delayed. It has been theoretically proven that a 25% reduction in fault tolerance can increase performance by 97%. AFRAID effectively changes the failure model of single fault tolerant arrays because a codeword that does not have updated parity is susceptible to disk failures.

Instead of sacrificing fault tolerance, you can use traditional performance techniques such as caching. Given that disk traffic is bursty, you can use a writeback cache to store data when the disks are busy. And if the cache memory is made in the form of non-volatile memory, then, in the event of a power failure, the data will be saved. In addition, deferred disk operations make it possible to randomly combine small blocks to perform more efficient disk operations.

There are also many architectures that sacrifice volume to increase performance. Among them are delayed modification on the log disk and various schemes for modifying the logical placement of data into the physical one, which allow you to distribute operations in the array more efficiently.

One of the options - parity logging(parity registration), which involves solving the small-write problem and more efficient use of disks. Parity logging defers parity changes to RAID 5 by recording them in a FIFO log, which is located partly in the controller's memory and partly on disk. Given that accessing a full track is on average 10 times more efficient than accessing a sector, parity logging collects large amounts of modified parity data, which are then written together to a disk dedicated to storing parity across the entire track.

Architecture floating data and parity(floating and parity), which allows the physical placement of disk blocks to be reallocated. Free sectors are placed on each cylinder to reduce rotational latency(rotation delays), data and parity are allocated to these free spaces. To ensure operation during a power failure, the parity and data map must be stored in non-volatile memory. If you lose the placement map, all data in the array will be lost.

Virtual stripping- is a floating data and parity architecture using writeback cache. Naturally realizing the positive sides of both.

In addition, there are other ways to improve performance, such as RAID operations. At one time, Seagate built support for RAID operations into its drives with Fiber interface Chanel and SCSI. This made it possible to reduce traffic between the central controller and the disks in the array for RAID 5 systems. This was a fundamental innovation in the field of RAID implementations, but the technology did not get a start in life, since some features of Fiber Chanel and SCSI standards weaken the failure model for disk arrays.

For the same RAID 5, the TickerTAIP architecture was introduced. It looks like this - the central control mechanism originator node (initiator node) receives user requests, selects a processing algorithm and then transfers disk work and parity to the worker node (work node). Each worker node processes a subset of the disks in the array. As in the Seagate model, worker nodes transfer data among themselves without the participation of the initiating node. If a worker node fails, the disks it served become unavailable. But if the codeword is constructed in such a way that each of its symbols is processed by a separate worker node, then the fault tolerance scheme repeats RAID 5. To prevent failures of the initiating node, it is duplicated, thus we get an architecture that is resistant to failures of any of its nodes. For all its positive features, this architecture suffers from the “write hole” problem. Which means an error occurs when several users change the codeword at the same time and the node fails.

It is also worth mentioning a fairly popular method for quickly restoring RAID - using free disk(spare). If one of the disks in the array fails, the RAID can be restored using a free disk instead of the failed one. The main feature of this implementation is that the system goes to its previous (fail-safe state without external intervention). When using a distributed sparing architecture, the logical blocks of a spare disk are physically distributed across all disks in the array, eliminating the need to rebuild the array if a disk fails.

In order to avoid the recovery problem typical of classic RAID levels, an architecture called parity declustering(parity distribution). It involves placing fewer logical drives with a large volume to physical disks of a smaller volume, but of a larger quantity. Using this technology, the system's response time to a request during reconstruction is improved by more than half, and reconstruction time is significantly reduced.

Architecture of Basic RAID Levels

Now let's look at the architecture of the basic levels of RAID in more detail. Before considering, let's make some assumptions. To demonstrate the principles of constructing RAID systems, consider a set of N disks (for simplicity, we will assume that N is an even number), each of which consists of M blocks.

We will denote the data - D m,n, where m is the number of data blocks, n is the number of subblocks into which the data block D is divided.

Disks can connect to either one or several data transfer channels. Using more channels increases system throughput.

RAID 0. Striped Disk Array without Fault Tolerance

It is a disk array in which data is divided into blocks, and each block is written (or read) to a separate disk. Thus, multiple I/O operations can be performed simultaneously.

Advantages:

• highest performance for applications requiring intensive processing of I/O requests and large data volumes;
• ease of implementation;
• low cost per unit volume.

Flaws:

• not a fault-tolerant solution;
• The failure of one drive results in the loss of all data in the array.

RAID 1. Redundant disk array or mirroring

Mirroring is a traditional way to increase the reliability of a small disk array. In the simplest version, two disks are used, on which the same information is recorded, and if one of them fails, a duplicate of it remains, which continues to operate in the same mode.

Advantages:

• ease of implementation;
• ease of array recovery in case of failure (copying);
• sufficiently high performance for applications with high request intensity.

Flaws:

• high cost per unit volume - 100% redundancy;
• low data transfer speed.

RAID 2. Fault-tolerant disk array using Hamming Code ECC.

The redundant coding used in RAID 2 is called Hamming code. The Hamming code allows you to correct single faults and detect double faults. Today it is actively used in data encoding technology in random access memory ECC type. And encoding data on magnetic disks.

In this case, an example is shown with a fixed number of disks due to the cumbersomeness of the description (a data word consists of 4 bits, respectively, the ECC code is 3).

Advantages:

• fast error correction (“on the fly”);
• very high data transfer speed for large volumes;
• as the number of disks increases, overhead costs decrease;
• quite simple implementation.

Flaws:

• high cost with a small number of disks;
• low speed request processing (not suitable for transaction-oriented systems).

RAID 3. Fault-tolerant array with parallel data transfer and parity (Parallel Transfer Disks with Parity)

Data is divided into subblocks at the byte level and written simultaneously to all disks in the array except one, which is used for parity. Using RAID 3 solves the problem of high redundancy in RAID 2. Most control disks, used in RAID level 2, are needed to determine the position of the faulty bit. But this is not necessary, since most controllers are able to determine when a disk has failed using special signals, or additional encoding of information written to the disk and used to correct random failures.

Advantages:

• very high data transfer speed;
• disk failure has little effect on the speed of the array;

Flaws:

• difficult implementation;
• low performance with high intensity requests for small data volumes.

RAID 4. Fault-tolerant array of independent disks with shared parity disk (Independent Data disks with shared Parity disk)

Data is broken down at the block level. Each block of data is written to a separate disk and can be read separately. Parity for a group of blocks is generated on write and checked on read. RAID Level 4 improves transfer performance small volumes data through parallelism, making it possible to perform more than one I/O access at the same time. The main difference between RAID 3 and 4 is that in the latter, data striping is performed at the sector level, rather than at the bit or byte level.

Advantages:

• very high speed of reading large volumes of data;
• high performance at high intensity of data reading requests;
• low overhead to implement redundancy.

Flaws:

• very low performance when writing data;
• low speed of reading small data with single requests;
• asymmetry of performance regarding reading and writing.

RAID 5. Fault-tolerant array of independent disks with distributed parity (Independent Data disks with distributed parity blocks)

This level is similar to RAID 4, but unlike the previous one, parity is distributed cyclically across all disks in the array. This change improves the performance of writing small amounts of data on multitasking systems. If write operations are planned properly, it is possible to process up to N/2 blocks in parallel, where N is the number of disks in the group.

Advantages:

• high data recording speed;
• fairly high data reading speed;
• high performance at high intensity of data read/write requests;
• low overhead to implement redundancy.

Flaws:

• Data reading speed is lower than in RAID 4;
• low speed of reading/writing small data with single requests;
• quite complex implementation;
• complex data recovery.

RAID 6. Fault-tolerant array of independent disks with two independent distributed parity schemes (Independent Data disks with two independent distributed parity schemes)

Data is partitioned at the block level, similar to RAID 5, but in addition to the previous architecture, a second scheme is used to improve fault tolerance. This architecture is double fault tolerant. However, when performing a logical write, there are actually six disk accesses, which greatly increases the processing time of one request.

Advantages:

• high fault tolerance;
• fairly high speed of request processing;
• relatively low overhead for implementing redundancy.

Flaws:

• very complex implementation;
• complex data recovery;
• very low data writing speed.

Modern RAID controllers allow you to combine different RAID levels. In this way, it is possible to implement systems that combine the advantages of different levels, as well as systems with a large number of disks. Typically this is a combination of level zero (stripping) and some kind of fault-tolerant level.

RAID 10. Fault-tolerant array with duplication and parallel processing

This architecture is a RAID 0 array whose segments are RAID 1 arrays. It combines very high fault tolerance and performance.

Advantages:

• high fault tolerance;
• high performance.

Flaws:

• very high cost;
• limited scaling.

RAID 30. Fault-tolerant array with parallel data transfer and increased performance.

It is a RAID 0 array, the segments of which are RAID 3 arrays. It combines fault tolerance and high performance. Typically used for applications requiring large volumes of serial data transfer.

Advantages:

• high fault tolerance;
• high performance.

Flaws:

• high price;
• limited scaling.

RAID 50: Fault-tolerant array with distributed parity and increased performance

It is a RAID 0 array, the segments of which are RAID 5 arrays. It combines fault tolerance and high performance for applications with high request intensity and high data transfer rates.

Advantages:

• high fault tolerance;
• high data transfer speed;
• high speed of request processing.

Flaws:

• high price;
• limited scaling.

RAID 7: Fault-tolerant array optimized for performance. (Optimized Asynchrony for High I/O Rates as well as High Data Transfer Rates). RAID 7® is a registered trademark of Storage Computer Corporation (SCC)

To understand the RAID 7 architecture, let's look at its features:

1. All data transfer requests are processed asynchronously and independently.
2. All read/write operations are cached via the high-speed x-bus.
3. The parity disk can be placed on any channel.
4. The microprocessor of the array controller uses a real-time operating system focused on processing processes.
5. The system has good scalability: up to 12 host interfaces and up to 48 disks.
6. The operating system controls the communication channels.
7. Standard SCSI disks, buses, motherboards and memory modules are used.
8. A high-speed X-bus is used to work with internal cache memory.
9. The parity generation procedure is integrated into the cache.
10. Disks attached to the system can be declared as separate.
11. An SNMP agent can be used to manage and monitor the system.

Advantages:

• high data transfer speed and high request processing speed (1.5 - 6 times higher than other standard RAID levels);
• high scalability of host interfaces;
• the data writing speed increases with the number of disks in the array;
• There is no need for additional data transmission to calculate parity.

Flaws:

• property of one manufacturer;
• very high cost per unit volume;
• short warranty period;
• cannot be serviced by the user;
• need to use block uninterruptible power supply to prevent data loss from cache memory.

Let's now consider standard levels together to compare their characteristics. The comparison is made within the framework of the architectures mentioned in the table.

Clarifications:

• * - the commonly used option is considered;
• k - number of subsegments;
• R - reading;
• W - record.

Some aspects of implementing RAID systems

Let's consider three main options for implementing RAID systems:

• software (software-based);
• hardware - bus-based;
• hardware - autonomous subsystem (subsystem-based).

It is impossible to say unequivocally that any implementation is better than another. Each option for organizing an array satisfies one or another user’s needs, depending on financial capabilities, the number of users and the applications used.

Each of the above implementations is based on the execution of program code. They actually differ in where this code is executed: in the computer’s central processor (software implementation) or in a specialized processor on a RAID controller (hardware implementation).

The main advantage of software implementation is low cost. But at the same time, it has many disadvantages: low performance, load on the central processor with additional work, and increased bus traffic. Simple RAID levels 0 and 1 are usually implemented in software, since they do not require significant computation. Taking these features into account, software-based RAID systems are used in entry-level servers.

Hardware RAID implementations accordingly cost more than software ones, since they use additional hardware to perform I/O operations. At the same time, they unload or free up the central processor and system bus and, accordingly, allow for increased performance.

Bus-oriented implementations are RAID controllers that use the high-speed bus of the computer in which they are installed (lately the PCI bus is usually used). In turn, bus-oriented implementations can be divided into low-level and high-level. The former usually do not have SCSI chips and use the so-called RAID port on the motherboard with a built-in SCSI controller. In this case, the functions of processing RAID code and I/O operations are distributed between the processor on the RAID controller and the SCSI chips on the motherboard. Thus, the central processor is freed from processing additional code and bus traffic is reduced compared to software option. The cost of such boards is usually low, especially if they are aimed at RAID 0 or 1 systems (there are also implementations of RAID 3, 5, 10, 30, 50, but they are more expensive), due to which they are gradually displacing software implementations from the entry-level server market. High-level controllers with bus implementation have a slightly different structure than their younger brothers. They take on all functions related to I/O and RAID code execution. Also, they are not so implementation dependent motherboard and, as a rule, have more capabilities (for example, the ability to connect a module to store information in a cache in the event of a motherboard failure or power failure). Such controllers are usually more expensive than low-end controllers and are used in mid- and high-end servers. They typically implement RAID levels 0.1, 3, 5, 10, 30, 50. Given that bus-oriented implementations connect directly to the internal PCI bus computers, they are the most productive among the systems under consideration (when organizing single-host systems). The maximum performance of such systems can reach 132 MB/s (32bit PCI) or 264 MB/s (64bit PCI) at a bus frequency of 33MHz.

Along with the listed advantages, the bus-oriented architecture has the following disadvantages:

• dependence operating system and platforms;
• limited scalability;
• limited capabilities for organizing fault-tolerant systems.

All these disadvantages can be avoided by using autonomous subsystems. These systems have a completely autonomous external organization and, in principle, are a separate computer that is used to organize information storage systems. In addition, in the event of successful development of fiber optic channel technology, the performance autonomous systems will not be inferior to bus-oriented systems in any way.

Typically, an external controller is placed in a separate rack and, unlike systems with a bus organization, can have a large number of input/output channels, including host channels, which makes it possible to connect several host computers to the system and organize cluster systems. In systems with a stand-alone controller, hot standby controllers can be implemented.

One of the disadvantages of autonomous systems is their high cost.

Taking into account the above, we note that autonomous controllers are usually used to implement high-capacity data storage and cluster systems.

The problem of increasing the reliability of information storage is always on the agenda. This is especially true for large amounts of data, databases on which the operation of complex systems in a wide range of industries depends. This is especially important for high-performance servers.

As you know, the performance of modern processors is constantly growing, which modern processors clearly cannot keep up with in their development.
hard disks. Having one disk, be it SCSI or, even worse, IDE, is already won't be able to decide tasks relevant to our time. You need many disks that will complement each other, replace them if one of them fails, store backup copies, and work efficiently and productively.

However, simply having several hard drives is not enough, you need them integrate into a system, which will work smoothly and will not allow data loss in the event of any disk-related failures.

You need to take care of creating such a system in advance, because, as the famous proverb says, Bye fried the rooster won't bite- they won’t miss it. You may lose your data irrevocably.

This system could become RAID– a virtual storage technology that combines several disks into one logical element. A RAID array is called redundant array independent disks. Typically used to improve performance and reliability.

What is needed to create a raid? At least two hard drives. Depending on the array level, the number of storage devices used varies.

What types of raid arrays are there?

There are basic, combination RAID arrays. The Berkeley Institute in California proposed dividing the raid into specification levels:

• Basic:
  • RAID 1 ;
  • RAID 2 ;
  • RAID 3 ;
  • RAID 4 ;
  • RAID 5 ;
  • RAID 6 .
• Combined:
  • RAID 10 ;
  • RAID 01 ;
  • RAID 50 ;
  • RAID 05 ;
  • RAID 60 ;
  • RAID 06 .

Let's look at the most commonly used ones.

Raid 0

RAID 0 intended to increase speed and recording. It does not increase storage reliability and is therefore not redundant. His other name is stripe (striping - “alternation”). Usually used from 2 to 4 disks.

The data is divided into blocks, which are written to disks one by one. Speed writing/reading increases by a number of times that is a multiple of the number of disks. From shortcomings One can note the increased likelihood of data loss with such a system. It makes no sense to store databases on such disks, because any serious failure will lead to complete inoperability of the raid, since there are no recovery tools.

Raid 1

RAID 1 provides mirror data storage at the hardware level. Also called an array Mirror, What means « mirror» . That is, the disk data in this case is duplicated. Can use with the number of storage devices from 2 to 4.

Speed writing/reading practically does not change, which can be attributed to benefits. The array works if at least one raid disk is in operation, but the system volume is equal to the volume of one disk. In practice, when failure one of the hard drives, you will need to take steps to replace it as quickly as possible.

Raid 2

RAID 2 - uses the so-called Hamming code. Data is split across hard drives similar to RAID 0, and is stored on the remaining drives error correction codes, in case of failure by which you can regenerate information. This method allows on-the-fly find, and then correct system failures.

Rapidity read/write in this case compared to using one disk rises. The downside is the large number of disks, for which it is rational to use it so that there is no data redundancy, usually this 7 and more.

RAID 3 - in an array, the data is split across all disks except one, which stores the parity bytes. Resistant to system failures. If one of the disks fails. Then its information can be easily “raised” using parity checksum data.

Compared to RAID 2 no possibility error correction on the fly. This array is different high performance and the ability to use 3 disks or more.

Main minus Such a system can be considered an increased load on the disk that stores parity bytes and low reliability of this disk.

Raid 4

In general, RAID 4 is similar to RAID 3 except difference that parity data is stored in blocks rather than bytes, which allows for increased speed of small data transfers.

Minus The specified array turns out to have a write speed, because write parity is generated on one single disk, just like RAID 3.

This seems to be a good solution for those servers where files are read more often than written.

Raid 5

RAID 2 to 4 have disadvantages due to the inability to parallelize write operations. RAID 5 eliminates this drawback. Parity blocks are written simultaneously to all disk devices in the array, no asynchrony in the data distribution, which means parity is distributed.

Number used hard drives from 3. The array is very common due to its versatility And efficiency, the greater the number of disks used, the more economical the disk space will be spent. Speed wherein high due to data parallelization, but performance decreases compared to RAID 10 due to large number operations. If one drive fails, reliability drops to RAID 0. It takes a long time to recover.

Raid 6

RAID 6 technology is similar to RAID 5, but higher reliability by increasing the number of parity disks.

However, at least 5 disks and a more powerful processor are already required to process the increased number of operations, and the number of disks must be equal to the prime number 5,7,11 and so on.

Raid 10, 50, 60

Next come combinations the previously mentioned raids. For example, RAID 10 is RAID 0 + RAID 1.

They inherit and advantages arrays of their components in terms of reliability, performance and number of disks, and at the same time efficiency.

Creating a raid array on a home PC

The advantages of creating a raid array at home are not obvious, due to the fact that it uneconomical, data loss is not so critical in comparison with servers, but information can be stored in backup copies, making backups periodically.

For these purposes you will need raid controller, which has its own BIOS and its own settings. In modern motherboards raid controller maybe integrated V south bridge chipset. But even in such boards, you can connect another controller by connecting to a PCI or PCI-E connector. Examples include devices from Silicon Image and JMicron.

Each controller can have its own configuration utility.

Let's look at creating a raid using the Intel Matrix Storage Manager Option ROM.

Transfer all data from your disks, otherwise during the creation of the array they will be cleared.

Go to BIOSSetup your motherboard and turn on the operating mode RAID for your sata hard drive.

To launch the utility, restart your PC, click ctrl+i during the procedure POST. In the program window you will see a list of available disks. Click Create Massive. Next select required array level.

In the future, following the intuitive interface, enter array size And confirm its creation.

Greetings to all, dear readers of the blog site. I think many of you have at least once come across such an interesting expression on the Internet - “RAID array”. What it means and why the average user might need it, that’s what we’ll talk about today. It is a well-known fact that it is the slowest component in a PC, and is inferior to the processor and.

To compensate for the “innate” slowness where it is completely out of place (we are talking primarily about servers and high-performance PCs), they came up with the use of a so-called RAID disk array - a kind of “bundle” of several identical hard drives operating in parallel. This solution allows you to significantly increase the speed of operation coupled with reliability.

First of all, a RAID array allows you to provide high fault tolerance for the hard drives (HDD) of your computer by combining several hard drives into one logical element. Accordingly, to implement this technology you will need at least two hard drives. In addition, RAID is simply convenient, because all the information that previously had to be copied to backup sources(, external hard drives), now you can leave it “as is,” because the risk of its complete loss is minimal and tends to zero, but not always, more on that below.

RAID translates roughly like this: a protected set of inexpensive disks. The name comes from the times when large hard drives were very expensive and it was cheaper to assemble one common array of smaller disks. The essence has not changed since then, in general, like the name, only now you can make just a gigantic storage out of several large HDDs, or make it so that one disk duplicates another. You can also combine both functions, thereby getting the advantages of one and the other.

All these arrays are under their own numbers, most likely you have heard about them - raid 0, 1...10, that is, arrays of different levels.

Types of RAID

Speed ​​Raid 0

Raid 0 has nothing to do with reliability, because it only increases speed. You need at least 2 hard drives, and in this case the data will be “cut” and written to both disks simultaneously. That is, you will have access to the full capacity of these disks, and theoretically this means that you get 2 times higher read/write speeds.

But let's imagine that one of these disks breaks down - in this case, the loss of ALL your data is inevitable. In other words, you will still have to make regular backups in order to be able to restore the information later. Typically 2 to 4 disks are used here.

Raid 1 or “mirror”

Reliability is not compromised here. You get the disk space and performance of only one hard drive, but you have double the reliability. One disk breaks - the information will be saved on the other.

The RAID 1 level array does not affect the speed, but the volume - here you have at your disposal only half of the total disk space, of which, by the way, in RAID 1 there can be 2, 4, etc., that is, an even number. In general, the main feature of a first-level raid is reliability.

Raid 10

Combines all the best of the previous types. I propose to look at how this works using the example of four HDDs. So, information is written in parallel on two disks, and this data is duplicated on two other disks.

The result is a 2-fold increase in access speed, but also the capacity of only two of the four disks in the array. But if any two disks fail, no data loss will occur.

Raid 5

This type of array is very similar to RAID 1 in its purpose, only now you need at least 3 disks, one of them will store the information necessary for recovery. For example, if such an array contains 6 HDDs, then only 5 of them will be used to record information.

Due to the fact that data is written to several hard drives at once, the reading speed is high, which is perfect for storing a large amount of data there. But, without an expensive raid controller, the speed will not be very high. God forbid one of the disks breaks - restoring information will take a lot of time.

Raid 6

This array can survive the failure of two hard drives at once. This means that to create such an array you will need at least four disks, despite the fact that the write speed will be even lower than that of RAID 5.

Please note that without a powerful raid controller, such an array (6) is unlikely to be assembled. If you only have 4 hard drives, it is better to build RAID 1.

How to create and configure a RAID array

RAID controller

A raid array can be made by connecting several HDDs to a computer motherboard that supports this technology. This means that such a motherboard has an integrated controller, which is usually built into the . But, the controller can also be external, which is connected via a PCI or PCI-E connector. Each controller, as a rule, has its own configuration software.

The raid can be organized both at the hardware level and at the software level; the latter option is the most common among home PCs. Users do not like the controller built into the motherboard because of its poor reliability. In addition, if the motherboard is damaged, data recovery will be very problematic. At the software level, the role of the controller is played, if something happens, you can easily transfer your raid array to another PC.

Hardware

How to make a RAID array? To do this you need:

1. Get it somewhere with raid support (in case of hardware RAID);
2. Buy at least two identical hard drives. It is better that they are identical not only in characteristics, but also of the same manufacturer and model, and connected to the mat. board using one .
3. Transfer all data from your HDDs to other media, otherwise they will be destroyed during the raid creation process.
4. Next, you will need to enable RAID support in the BIOS, but I can’t tell you how to do this in the case of your computer, due to the fact that everyone’s BIOS is different. Usually this parameter is called something like this: “SATA Configuration or Configure SATA as RAID”.
5. Then restart your PC and a table with more detailed raid settings should appear. You may have to press the key combination "ctrl+i" during the POST procedure for this table to appear. For those who have an external controller, you will most likely need to press “F2”. In the table itself, click “Create Massive” and select the required array level.

After creating a raid array in the BIOS, you need to go to “disk management” in OS –10 and format the unallocated area - this is our array.

Program

To create a software RAID, you don't have to enable or disable anything in the BIOS. In fact, you don't even need raid support motherboard. As mentioned above, the technology is implemented using the PC’s central processor and Windows itself. Yep, you don't even need to install any third-party software. True, in this way you can only create a RAID of the first type, which is a “mirror”.

Right-click on “my computer” - “manage” - “disk management”. Then click on any of the hard drives intended for the raid (disk1 or disk2) and select “Create mirror volume.” In the next window, select a disk that will be a mirror of another hard drive, then assign a letter and format the final partition.

In this utility, mirrored volumes are highlighted in one color (red) and are designated by one letter. In this case, the files are copied to both volumes, once to one volume, and the same file is copied to the second volume. It is noteworthy that in the “my computer” window our array will be displayed as one section, the second section is hidden so as not to be an eyesore, because the same duplicate files are located there.

If a hard drive fails, the “Failed Redundancy” error will appear, while everything on the second partition will remain intact.

Let's summarize

RAID 5 is needed for a limited range of tasks, when a much larger number of HDDs (than 4 disks) are assembled into huge arrays. For most users, raid 1 is the best option. For example, if there are four disks with a capacity of 3 terabytes each, in RAID 1 in this case 6 terabytes of capacity are available. RAID 5 in this case will provide more space, however, the access speed will drop significantly. RAID 6 will give the same 6 terabytes, but even lower access speed, and will also require an expensive controller.

Let's add more RAID disks and you will see how everything changes. For example, let’s take eight disks of the same capacity (3 terabytes). In RAID 1, only 12 terabytes of space will be available for recording, half of the volume will be closed! RAID 5 in this example will give 21 terabytes of disk space + it will be possible to get data from any one damaged hard drive. RAID 6 will give 18 terabytes and data can be obtained from any two disks.

In general, RAID is not a cheap thing, but personally I would like to have at my disposal a RAID of the first level of 3 terabyte disks. There are even more sophisticated methods, like RAID 6 0, or “raid from raid arrays”, but this makes sense with a large number of HDDs, at least 8, 16 or 30 - you must agree, this goes far beyond the scope of normal “household” use and is used demand is mostly in servers.

Something like this, leave comments, add the site to bookmarks (for convenience), there will be many more interesting and useful things, and see you soon on the blog pages!