แแฃแจแแแแแก แแแฃแแฏแแแแกแแแแก แขแแฅแแแแแแแแแ, แ แแแแแแช แแแคแฃแซแแแแฃแแแ SSD-แแแแก แแแแแงแแแแแแแ แแ แคแแ แแแ แแแแแแงแแแแแ แจแแแแฎแแแก แกแแกแขแแแแแจแ, แแแแ แฎแแแแ แแแแแแแแแแก. แฃแแแ แแแแแก แงแแแแแกแ, แแก แแ แแก SSD-แแก แแแแแงแแแแแ แจแแแแฎแแแก แกแแแ แชแแ, แ แแแแแแช 100% แแคแแฅแขแฃแ แแ, แแแแ แแ แซแแแ แ. แแแแขแแ แแแแแแงแแแแแ แแแแฆแแแแ แแ แฅแแจแแ แแแแก แขแแฅแแแแแแแแแ, แกแแแแช SSD-แแแ แแแแแแงแแแแแ แแฎแแแแ แงแแแแแแ แแแแฃแแแ แฃแแ (โแชแฎแแแโ) แแแแแชแแแแแแกแแแแก. Tiering แแแ แแแ โแชแฎแแแโ แแแแแชแแแแแแก แแ แซแแแแแแแแแ (แแฆแ-แแแแ แแแแก) แแแแแงแแแแแแก แกแชแแแแ แแแแกแแแแก. แฅแแจแแ แแแ, แแแ แแฅแแ, แแ แแก แแแแแแแแแแแแ (แฌแฃแ-แกแแแแแแแ) แแแแแงแแแแแแกแแแแก. แแ แแแ แแก แแแ แแแแขแ แแแแแ แแแแแ แจแแแแฎแแแก แกแแกแขแแแแจแ
SSD แฅแแจแแ แแแแก แขแแฅแแแแแแแแก แแ แกแ แแ แแก SSD-แแแแก แแแแแงแแแแแ, แ แแแแ แช แจแฃแแแแแฃแ แ แฅแแจแ แแงแแ แแแกแแแแกแ แแ แแแแขแ แแแแ แแก RAM-แก แจแแ แแก. SSD-แแก แจแแกแ แฃแแแแ, แ แ แแฅแแ แฃแแแ, แฃแคแ แ แแแแแแแ, แแแแ แ แแแแขแ แแแแ แแก แกแแแฃแแแ แ แฅแแจแแก แจแแกแ แฃแแแแ, แแแแ แแ แแแชแฃแแแแ แฃแคแ แ แแแฆแแแแ. แแแ แแแแ, แฉแแแ แแแฆแแแ แแแ แแแแฃแ แแแแแ แแแแกแก แกแแฉแฅแแ แแกแ แแ แแแชแฃแแแแแก แจแแ แแก.
SSD แฅแแจแแก แแแแแงแแแแแแก แฉแแแแแแแแ แฌแแกแแแแแฎแแ:
- แฌแแแแแฎแแแก แแแแ แแชแแแแแก แฃแแแ แแขแแกแแแ แฉแแฌแแ แแก แแแแ แแชแแแแแ (แงแแแแแแ แฎแจแแ แแ แแแแแฎแแกแแแแแแแแแ แแแแแชแแแแ แแแแแแแกแแแแก แแ แแแ แแแแแแแชแแแแแกแแแแก);
- แแแแแแก แแ แกแแแแแ แแงแแ แ แแแกแแแก แแแกแแแแก แจแแกแ แฃแแแแแก แกแแฎแแ;
- แกแแญแแ แ แแแแแชแแแแแแก แ แแแแแแแแ แแแแแแแแ SSD แฅแแจแแก แแแแแแ.
แฌแแแแแฎแแ+แฉแแฌแแ แแก SSD แฅแแจแแก แแแแแงแแแแแแก แแแแแแแแแแ แแแแแแ, แแแ แแ แแแแ แแชแแแแแก แฎแแกแแแแแกแ โ แจแแ แแฃแแ แขแแแแก (แแแแแแแแแ, แคแแแแแก แกแแ แแแ แ).
แแแฎแกแแแ แแแแก แแแแฌแแแแแแแแแก แฃแแแขแแกแแแ แแงแแแแแก แแฎแแแแ แฌแแกแแแแแฎแแ SSD แฅแแจแก แแแ แแ แแแฃแฅแขแแแจแ. แคแฃแแแแแแแขแฃแ แ แแแแกแฎแแแแแแ
SSD แฅแแจแ XCubeSAN-แจแ แคแแแแแฃแ แแ แแ แแก แแแแแ แแแแ แชแแแแแฃแแ SSD แฅแแจแ แแฃแแแแแก แกแแฎแแ. แกแแกแขแแแแจแ แจแแแซแแแแ แแงแแก แแแฎแแแแ แแแแแแแ. แแแแแแฃแแ แแฃแแ, แ แ แแฅแแ แฃแแแ, แแงแแแแแก SSD-แแแแก แกแแแฃแแแ แแแแแแแฅแขแก. แแ แฃแแแ แแแ แขแฃแแแฃแ แ แแแกแแแก แแแแกแแแแแจแ แแแแแกแแแฆแแ แแแ, แแแแแแงแแแแแก แแฃ แแ แ แฅแแจแ แแฃแแก แแ แ แแแแแ. แขแแแแแแกแแแแก แฅแแจแแก แแแแแงแแแแแแก แฉแแ แแแ แแ แแแแแ แแแ แจแแแซแแแแ แแแแฎแแ แชแแแแแแก แแแแแแ แ แแแแแจแ I/O แจแแฉแแ แแแแก แแแ แแจแ. แแฅแแแ แแกแแแ แจแแแแซแแแแ แชแฎแแแ แแแแแแขแแ SSD-แแแ แแฃแแจแ แแ แแแแแฆแแ แแกแแแ แแฅแแแแ. SSD pool cache-แแก แจแแฅแแแแกแแก แแฅแแแ แฃแแแ แแแ แฉแแแ แ แ แ แแแแแจแ แแแฃแจแแแแแก แแก: แแฎแแแแ แฌแแแแแฎแแ แแ แฌแแแแแฎแแ+แฉแแฌแแ แ. แแแกแ แคแแแแแฃแ แ แแ แแแแแแแชแแ แแแแแแ แแแแแแแแแแฃแแ. แแแแแแแแ แจแแแซแแแแ แแ แกแแแแแแแก แ แแแแแแแแ แฅแแจแ แแฃแแ, แแแแ แคแฃแแฅแชแแแแแ แแแ แจแแแซแแแแ แแงแแก แแแแกแฎแแแแแแฃแแ (แแแฃ, แกแแกแขแแแแก แจแแฃแซแแแ แแ แแแ แแฃแแแ แฐแฅแแแแแก แ แแแแ แช แฌแแแแแฎแแแก, แแกแแแ แฌแแแแแฎแแแก แแ แฉแแฌแแ แแก แฅแแจแ แแฃแแ).
แแฃ แแแแแแงแแแแแ แแฎแแแแ แฌแแแแแฎแแแก แฅแแจแ, แแก แจแแแซแแแแ แจแแแแแแแแแก 1-8 SSD-แแกแแแ. แแแกแแแแ แแ แฃแแแ แแงแแก แแแแแ แขแแแแแแแแก แแ แแแแแ แแแแงแแแแแแ, แ แแแแแ แแกแแแ แแแแ แแแแแแแฃแแแ NRAID+ แกแขแ แฃแฅแขแฃแ แแจแ. แแฃแแจแ แแ แกแแแฃแแ แงแแแแ SSD แแ แแก แกแแแ แแ. แกแแกแขแแแ แแแแแฃแแแแแแแแ แชแแแแแแก แจแแแแแแแแแ แแแแฎแแแแแแแก แแแ แแแแแแแแแแก แงแแแแ SSD-แก แจแแ แแก, แ แแแ แแแแฆแฌแแแก แแแฅแกแแแแแฃแ แจแแกแ แฃแแแแแก. แแฃ แแ แ-แแ แแ SSD แแแ แชแฎแแแแ, แชแฃแแ แแ แแคแแ แ แแแฎแแแแ: แแแแแก แแ แแแแแก, แฅแแจแ แจแแแชแแแก แแฎแแแแ แแงแแ แ แแแกแแแแแก แแแกแแแแ แจแแแแฎแฃแแ แแแแแชแแแแแแก แแกแแก. แฃแแ แแแแ, แฎแแแแแกแแฌแแแแแ SSD แฅแแจแแก แ แแแแแแแแ แจแแแชแแ แแแแ (แแ แแแฎแแแแ แแฃแแ, แแฃ แแงแแแแแ แแ แแแแแแแฃแ แ SSD แฅแแจแ แแ แแ แแแกแแแแแ).
แแฃ แฅแแจแ แแแแแแงแแแแแ แฌแแแแแฎแแแก + แฉแแฌแแ แแก แแแแ แแชแแแแแกแแแแก, แแแจแแ SSD-แแแแก แ แแแแแแแแ แแฃแแจแ แฃแแแ แแงแแก แแ แแก แฏแแ แแแ, แ แแแแแ แจแแแแแแกแ แแกแแฎแฃแแแ แฌแงแแแ แแแกแแแแแ (แแแแแแงแแแแแ NRAID 1+ แกแขแ แฃแฅแขแฃแ แ). แฅแแจแแก แแฃแแแแ แแแ แแฃแชแแแแแแแแ, แ แแแแแ แแก แจแแแซแแแแ แจแแแชแแแแแก แแแแแชแแแแแก, แ แแแแแแแช แฏแแ แแ แแ แแก แฉแแฌแแ แแแ แแงแแ แแแกแแแ. แแ แแ แจแแแแฎแแแแแจแ, SSD-แแก แฃแแแแ แแกแแแ แฅแแจแแก แแฃแแแแแ แแแแแแฌแแแแก แแแคแแ แแแชแแแก แแแแแ แแแแก. NRAID 1+-แแก แจแแแแฎแแแแแจแ, SSD-แแก แฌแแ แฃแแแขแแแแแแ แฃแแ แแแแ แแแแแแฌแแแแก แฅแแจแแก แแแแแขแแแแก แแฎแแแแ แฌแแแแแฎแแแก แแแแแแแ แแแแแจแ, แแแฃแฌแแ แแแ แแแแแชแแแแแแก แแแแแงแ แ แแงแแ แ แแแกแแแก แแแกแแแแ. แแแฃแแแ แแแแ SSD-แแก แจแแชแแแแก แจแแแแแ, แฅแแจแ แฃแแ แฃแแแแแ แแแแแแแแ แแแ แแแแ แแชแแฃแ แ แแแแแก. แกแฎแแแแ แจแแ แแก, แฃแคแ แ แแแขแ แฃแกแแคแ แแฎแแแแแกแแแแก, แจแแแแซแแแแ แแแแแญแแ แแแแแงแแคแแแ แชแฎแแแ แแแฌแแแแแ แฌแแแแแฎแแแก + แฉแแฌแแ แแก แฅแแจแแกแแแแก.
XCubeSAN-แจแ SSD แฅแแจแแ แแแแก แคแฃแแฅแชแแแก แแแแแงแแแแแแกแแก, แแ แกแแแแแก แแแแแ แ แแแ แแแแฎแแแแแแ แกแแชแแแแก แแแแขแ แแแแ แแแแก แแแฎแกแแแ แแแแก แแแแแแแแกแแแ แแแแแแจแแ แแแแ: แ แแช แแแขแ แกแแกแขแแแฃแ แ แแแฎแกแแแ แแแ, แแแ แฃแคแ แ แแแแ แแฅแแแแ แฅแแจแแก แแฃแแ.
แกแแชแแแแก แกแแกแขแแแแแแก แแฌแแ แแแแแแแแแก แฃแแแขแแกแแแแกแแแ แแแแกแฎแแแแแแแ, แ แแแแแแแช แแฎแแแแ SSD แฅแแจแแก แฉแแ แแแแก/แแแแแ แแแแก แแแ แแแแขแก แแแแแแแแแแแ, QSAN แแแแแแแแแ แแแข แแแ แแแแขแก. แแแ แซแแ, แจแแแแซแแแแ แแแ แฉแแแ แฅแแจแ แแฃแจแแแแแก แ แแแแแ แแแขแแแ แแแแก แฎแแกแแแแแแแ แแแแแแแแแแ แ. แแ แกแแแแแก แกแแแ แฌแแแแกแฌแแ แแแงแแแแแฃแแ แจแแแแแแ, แ แแแแแแแช แแแแแแแ แคแฃแแฅแชแแแแแ แแแแจแ แงแแแแแแ แแฎแแแก แแ แแแ แจแแกแแแแแแก แกแแ แแแกแแแแแ: แแแแแชแแแแ แแแแ, แคแแแแฃแ แ แกแแกแขแแแ, แแแ แกแแ แแแกแ. แแแ แแ แแแแกแ, แแแแแแแกแขแ แแขแแ แก แจแแฃแซแแแ แจแแฅแแแแก แกแแแฃแแแ แ แแ แแคแแแ แแแ แแแแขแ แแก แกแแญแแ แ แแแแจแแแแแแแแแแก แแแงแแแแแแ:
- แแแแแแก แแแแ (Cache Block Size) โ 1/2/4 MB
- แแแแแแก แฌแแแแแฎแแแก แแแแฎแแแแแก แ แแแแแแแแ แแกแ, แ แแ แแก แแแแแแแ แแแก แฅแแจแจแ (Populate-on-Read Threshold) โ 1..4
- แแแแฎแแแแแก แ แแแแแแแแ แแแแแแก แฉแแกแแฌแแ แแ แแกแ, แ แแ แแก แแแแแแแ แแแก แฅแแจแจแ (แฉแแฌแแ แแก แแแ แแแ แ แจแแแกแแแ) โ 0..4
แแ แแคแแแแแแก แจแแชแแแ แจแแกแแซแแแแแแแ แคแ แแแแก แแ แแก, แแแแ แแ, แ แ แแฅแแ แฃแแแ, แฅแแจแแก แแแแแขแแแ แแแแก แจแแแแแ แกแแ แแ แแแกแ แแฎแแแ โแแแแแแแแโ.
SSD แฅแแจแแก แแฃแจแแแแแก แแ แแแชแแแแก แแแแแแแแกแฌแแแแแแ, แฉแแแ แจแแแแแซแแแ แแแแแแงแแ แซแแ แแแแแ แแแแ แแชแแแแ แแแกแแแ แแฃแจแแแแแกแแก:
แแแแแชแแแแแแก แฌแแแแแฎแแ, แ แแแแกแแช แแก แแ แแ แแก แฅแแจแจแ; แฌแแแแแแฎแแ แแแแแชแแแแแ, แ แแแแกแแช แแก แแแงแแคแแแ แฅแแจแจแ; แฌแแแแแฎแฃแแ แฅแแจแแก แแแแแงแแแแแแกแแก แแแแแชแแแแแแก แฉแแฌแแ แ; แแแแแชแแแแแแก แฉแแฌแแ แ แฌแแแแแฎแแแก + แฉแแฌแแ แแก แฅแแจแแก แแแแแงแแแแแแกแแก.
แแแแแชแแแแแแก แฌแแแแแฎแแ, แ แแแแกแแช แแก แแ แแ แแก แฅแแจแจแ
- แแแกแแแแซแแแก แแแแฎแแแแ แแแแแก แแแแขแ แแแแ แแแ;
- แแแแแแแแ แแแแฎแแแแแแ แแ แแ แแก SSD แฅแแจแจแ, แแกแแแ แแแแแฎแแแ แแงแแ แ แแแกแแแแแแแ;
- แฌแแแแแฎแฃแแ แแแแแชแแแแแ แแแแแแแแแ แแแกแแแแซแแแก. แแแแแแ แแฃแแแ, แแแแแแแ แจแแแแฌแแแแ, แแ แแก แแฃ แแ แ แแก แแแแแแแ "แชแฎแแแ";
- แแฃ แแ, แแแจแแ แแกแแแ แแแแแ แแแแ SSD แฅแแจแจแ แจแแแแแแแ แแแแแงแแแแแแกแแแแก.
แฌแแแแแแฎแแ แแแแแชแแแแแ, แ แแแแกแแช แแก แแแงแแคแแแ แฅแแจแจแ
- แแแกแแแแซแแแก แแแแฎแแแแ แแแแแก แแแแขแ แแแแ แแแ;
- แแแแแแแแ แแแแฎแแแแแแ แแแแแชแแแแแ แแ แแก SSD แฅแแจแจแ, แแก แแฅแแแแ แแแแแฎแแแ;
- แฌแแแแแฎแฃแแ แแแแแชแแแแแ แแแแแแแแแ แแแกแแแแซแแแก.
แแแแแชแแแแแแก แฉแแฌแแ แ แฌแแแแแฎแฃแแ แฅแแจแแก แแแแแงแแแแแแกแแก
- แฉแแฌแแ แแก แแแแฎแแแแ แฐแแกแขแแกแแแ แแแแแก แแแแขแ แแแแ แแแ;
- แแแแแชแแแแแ แแฌแแ แแแ แแงแแ แแแกแแแแแ;
- แแแกแฃแฎแ, แ แแแแแแช แแแฃแแแแแแก แฌแแ แแแขแแแฃแ แฉแแฌแแ แแแ, แฃแแ แฃแแแแแ แแแกแแแแซแแแก;
- แแแแแแ แแฃแแแ, แแแฌแแแแแ แแ แแก แแฃ แแ แ แแแแแ โแชแฎแแแโ (แจแแแแ แแแฃแแแ Populate-on-Write Threshold แแแ แแแแขแ แ). แแฃ แแ, แแแจแแ แแก แแแแแ แแแแ SSD แฅแแจแจแ แจแแแแแแแ แแแแแงแแแแแแกแแแแก.
แแแแแชแแแแแแก แฉแแฌแแ แ แฌแแแแแฎแแ+แฉแแฌแแ แแก แฅแแจแแก แแแแแงแแแแแแกแแก
- แฉแแฌแแ แแก แแแแฎแแแแ แฐแแกแขแแกแแแ แแแแแก แแแแขแ แแแแ แแแ;
- แแแแแชแแแแแ แแฌแแ แแแ SSD แฅแแจแจแ;
- แแแกแฃแฎแ, แ แแแแแแช แแแฃแแแแแแก แฌแแ แแแขแแแฃแ แฉแแฌแแ แแแ, แฃแแ แฃแแแแแ แแแกแแแแซแแแก;
- แแแแแชแแแแแ SSD แฅแแจแแแแ แแฌแแ แแแ แแงแแ แแแกแแแแแ แคแแแแ;
แจแแแแฌแแแแ แแแฅแแแแแแแจแ
แกแแขแแกแขแ แกแขแแแแ
2 แกแแ แแแ แ (CPU: 2 x Xeon E5-2620v3 2.4Hz / แแแแ แแขแแฃแแ แแแฎแกแแแ แแแ: 32 GB) แแแแแแจแแ แแแฃแแแ แแ แ แแแ แขแแ Fiber Channel 16G-แแก แแแจแแแแแแ แแแ แแแแแ XCubeSAN XS5224D แจแแแแฎแแแก แกแแกแขแแแแกแแแ (16GB RAM/แแแแขแ แแแแ แ).
แฉแแแ แแแแแแแงแแแแ 16 x Seagate Constellation ES, ST500NM0001, 500 GB, SAS 6 แแ/แฌแ, แแแแ แแแแแแแฃแแ RAID5-แจแ (15+1), แแแแแชแแแแ แแแกแแแแกแแแแก แแ 8 x HGST Ultrastar SSD800MH.B, HUSMH8010BSS200, SSS100, SAS12
แจแแแฅแแแ 2 แขแแแ: แแ แแ แแแแแแฃแแ แกแแ แแแ แแกแแแแก.
แขแแกแขแ 1. แแฎแแแแ แฌแแแแแฎแแแแ SSD แฅแแจแ 1-8 SSD-แแแ
SSD แฅแแจแ
- I/O แขแแแ: แแแ แกแแแแแแแแชแแ
- แฅแแจแแก แแแแแแก แแแแ: 4 แแ
- แจแแแแกแแ แฌแแแแแฎแแแก แแฆแแแ แ: 1
- แฉแแฌแแ แแก แแแ แแแ แ แจแแแกแแแ: 0
I/O แแแแฃแจแ
- แแแกแขแ แฃแแแแขแ: IOmeter V1.1.0
- แแฃแจแแแ: 1
- แแแแแ แฉแแฃแแ (แ แแแแแแก แกแแฆแ แแ): 128
- แฌแแแแแแก แกแแแชแแคแแแแชแแแแ: 4KB, 100% แฌแแแแแฎแฃแแ, 100% แจแแแแฎแแแแแแ
แแแแ แแฃแแแ, แ แแช แฃแคแ แ แแแขแ SSD แแ แแก แฅแแจแ, แแแ แฃแคแ แ แแแฆแแแแ แจแแกแ แฃแแแแ. แแ แแฅแขแแแแจแ แแก แแแแแกแขแฃแ แแ. SSD-แแแแก แ แแแแแแแแแก แแ แแแแแ แแ แแแแจแแแแแแแแแ แแ แแ แแชแแ แ แ แแแแแแแแแ แแแชแฃแแแแแ แแ แแฌแแแแก แแกแแคแแแฅแแแแ แแคแแฅแขแก.
แขแแกแขแ 2. SSD แฅแแจแ แฌแแแแแฎแแแก + แฉแแฌแแ แแก แ แแแแแจแ 2-8 SSD-แแ
SSD แฅแแจแ
- I/O แขแแแ: แแแ แกแแแแแแแแชแแ
- แฅแแจแแก แแแแแแก แแแแ: 4 แแ
- แจแแแแกแแ แฌแแแแแฎแแแก แแฆแแแ แ: 1
- แฉแแฌแแ แแก แแแ แแแ แ แจแแแกแแแ: 1
I/O แแแแฃแจแ
- แแแกแขแ แฃแแแแขแ: IOmeter V1.1.0
- แแฃแจแแแ: 1
- แแแแแ แฉแแฃแแ (แ แแแแแแก แกแแฆแ แแ): 128
- แฌแแแแแแก แกแแแชแแคแแแแชแแแแ: 4KB, 100% แฉแแฌแแ แ, 100% แจแแแแฎแแแแแแ
แแแแแ แจแแแแแ: แแกแแคแแแฅแแแแแ แจแแกแ แฃแแแแแก แแ แแ แแ แแแกแจแขแแแแ แแแ SSD-แแแแก แ แแแแแแแแแก แแแขแแแแกแแแ แแ แแแ.
แแ แแแ แขแแกแขแจแ, แกแแแฃแจแแ แแแแแชแแแแแแก แ แแแแแแแแ แแแแแแแ แแงแ แฅแแจแแก แแแแแแ แแแแแแ. แแแแขแแ, แแ แแแ แแแแแแแแแแแจแ, แงแแแแ แแแแแ แแแแแแแ แแ แฅแแจแจแ. แแ แแฃแจแแแแ, แคแแฅแขแแแ แแแแ, แฃแแแ แฉแแขแแ แแ SSD-แแแแ, แแ แแฅแขแแแฃแแแ แแงแแ แแแกแแแแแ แแแแแแแแก แแแ แแจแ. แแ แขแแกแขแแแแก แแแแแแ แแงแ แแแแแแ แแฉแแแแแแแแ แฅแแจแแก แแแฎแฃแ แแแแก แแคแแฅแขแฃแ แแแ แแ แแแกแ แจแแกแ แฃแแแแแก แแแกแจแขแแแแ แแแ SSD-แแแแก แ แแแแแแแแแก แแแฎแแแแแ.
แแฎแแ แแแแแ แแแแฃแแ แฃแแแแ แแแแแแแฌแแก แแ แจแแแแแแฌแแแ แฃแคแ แ แ แแแแแกแขแฃแ แ แกแแขแฃแแชแแ, แ แแแแกแแช แแแแแชแแแแ แ แแแแแแแแ แแฆแแแแขแแแ แฅแแจแแก แแแแแก. แแแแกแแแแแก, แ แแ แขแแกแขแแ แแแแแ แแก แแแแแแ แฃแ แแ แแจแ (แฅแแจแแก โแแแฎแฃแ แแแแกโ แแแ แแแแ แแแแจแแแแแแแแแ แแแ แแแแ แแแชแฃแแแแแก แแแแแก แแแขแแแแกแแแ แแ แแแ), แฉแแแ แจแแแแฆแฃแแแแ แแแชแฃแแแแแก แแแแแก 120 แแ-แแแ.
แขแแกแขแ 3. แแแแแชแแแแ แแแแแก แแแฃแแแชแแ
SSD แฅแแจแ
- I/O แขแแแ: แแแแแชแแแแ แแแแ
- แฅแแจแแก แแแแแแก แแแแ: 1 แแ
- แจแแแแกแแ แฌแแแแแฎแแแก แแฆแแแ แ: 2
- แฉแแฌแแ แแก แแแ แแแ แ แจแแแกแแแ: 1
I/O แแแแฃแจแ
- แแแกแขแ แฃแแแแขแ: IOmeter V1.1.0
- แแฃแจแแแ: 1
- แแแแแ แฉแแฃแแ (แ แแแแแแก แกแแฆแ แแ): 128
- แฌแแแแแแก แกแแแชแแคแแแแชแแแแ: 8KB, 67% แฌแแแแแฎแฃแแ, 100% แจแแแแฎแแแแแแ
แแแแแฉแแแ
แแจแแแ แ แแแกแแแแ, แ แ แแฅแแ แฃแแแ, แแ แแก SSD แฅแแจแแก แแแแแงแแแแแแก แแแ แแ แแคแแฅแขแฃแ แแแ แแแแแกแแแแ แ แจแแแแฎแแแก แกแแกแขแแแแก แแฃแจแแแแแก แแแกแแฃแแฏแแแแกแแแแแ. แแแแแ แแ
QSAN XCubeSAN แแก แแแแชแฎแแแแแ แกแ แฃแแแ แแแแแแงแแแแแ: SSD แฅแแจแแ แแแแก แคแฃแแฅแชแแ แกแ แฃแแงแแคแแแแ แแ แแก แแแแแ แแแแ. แแก แแฎแแแ แฌแแแแแฎแแแก แแ แฌแแแแแฎแแแก + แฉแแฌแแ แแก แ แแแแแแแแก แแฎแแ แแแญแแ แแก, แแแฅแแแ แแแ แแแแขแ แแแก แแแแแกแแแแ แ แแแแแงแแแแแแก แกแชแแแแ แแกแแแแก, แแกแแแ แ แแแแ แช แแแแแแแ แกแแกแขแแแแก แแฃแจแแแแแก. แแแแขแแ, แซแแแแแ แแแแแแ แฃแแ แฆแแ แแแฃแแแแแกแแแแก (แแแชแแแแแแก แคแแกแ แจแแแแ แแแฃแแแ 1-2 SSD-แแก แฆแแ แแแฃแแแแแกแแแ), แจแแแแซแแแแ แแแแจแแแแแแแแแ แแแแแ แแแ แแแแแแแ แจแแกแ แฃแแแแ.
แฌแงแแ แ: www.habr.com