Я думаю стресс-тестирование, SD-карта находится в общем, проблематичном, учитывая 2 вещи:

1. износ, выравнивающийся, нет никаких гарантий, что одна запись к следующему на самом деле осуществляет те же физические местоположения на SD. Помните, что большинство систем SD на месте активно берет блок, поскольку мы знаем это и перемещение физического местоположения, которое поддерживает его вокруг на основе воспринятого "износа", которому было подвергнуто каждое местоположение.

2. различные технологии (MLC по сравнению с SLC) другая проблема, которую я вижу с этим, являются различием в технологиях. Типы SLC SSD я ожидал бы иметь намного более долгую жизнь по сравнению с разнообразием MLC. Также существуют намного более трудные допуски на MLC, что Вы просто не должны иметь дело с на SLC's, или по крайней мере они намного более терпимы к сбою таким образом.

   • MLC - Много ячейка уровня
   • SLC - Одноуровневая ячейка

Проблема с MLC состоит в том, что данная ячейка может сохранить несколько значений, биты по существу сложены с помощью напряжения, вместо того, чтобы просто быть физическим +5V или 0V, например, таким образом, это может привести к большому потенциалу большой частоты отказов, чем их эквивалент SLC.

Продолжительность жизни

Я нашел эту ссылку, которая обсуждает немного о том, сколько времени аппаратные средства могут прослужить. Это названо: Знайте Свои SSD - SLC по сравнению с MLC.

SLC

SLC ssds может быть вычислен, по большей части, для проживания где угодно между 49 годами и 149 годами, в среднем, наилучшими оценками. Тестирование Memoright может проверить SSD на 128 ГБ, имеющий продолжительность жизни износостойкости записи сверх 200 лет со средней записью 100 ГБ в день.

MLC

Это - то, где дизайн mlc терпит неудачу. Ни один не был выпущен на данный момент. Никто действительно не исследовал, какую продолжительность жизни гарантируют с mlc за исключением того, что, это будет значительно ниже. Я получил несколько различных верований, которые составляют в среднем от 10 до 1 продолжительности жизни в пользу дизайна slc. Консервативное предположение - то, что большинство оценок продолжительности жизни прибудет между 7 и 10 годами, в зависимости от продвижения ‘алгоритмов выравнивания износа’ в контроллерах каждого производителя.

Сравнения

Для провожения сравнения посредством циклов записи slc имел бы время жизни 100 000 полных циклов записи по сравнению с mlc, который имеет время жизни 10 000 циклов записи. Это могло значительно увеличиться в зависимости от дизайна ‘выравнивания износа’, используемого.

Просто добавление некоторых точек к ответу slm - отмечает, что они существуют больше для SSD, чем для "немых" SD-карт, так как SSD играют намного более грязные приемы с Вашими данными (например, дедупликация):

• Вы пишете 64 КБ в начало устройства - это само имеет две проблемы:

  1. ячейки флэш-памяти обычно имеют блоки стирания размера от 16 КБ (более вероятно в 128-512KB диапазоне, хотя). Что означает, что этому нужен кэш, по крайней мере, этого размера. Следовательно запись 64 КБ, кажется, не достаточно мне.

  2. для низкопроизводительного (чтение "непредприятие") решения (и я ожидал бы это еще больше для карт SD/CF, чем для SSD) производители могут принять решение сделать начало устройства более эластичным для износа, чем остальные начиная с важных структур - таблица разделов, и FAT на единственном разделе на устройстве (большинство карт памяти использует эту установку) - расположены там. Таким образом тестирование начала карты могло бы быть смещено.

• fdatasync() действительно не гарантирует, что данные записаны в физическую среду (хотя это, вероятно, прилагает все усилия то, что находится под контролем ОС) - см. страницу справочника:

  Блоки вызова, пока устройство не сообщает, что передача завершилась

  Я не был бы чрезмерно удивлен, оказалось ли, что существует маленький конденсатор, который может обеспечить энергию для записи кэшированных данных к флэш-памяти в случае потери внешнего питания.

  В любом случае, под предположением о кэше, присутствующем на карте (см. мой ответ на свой вопрос на SU), пишущий 64 КБ и синхронизируя (с fdatasync()) кажется, не убеждает достаточно с этой целью. Даже без любого "резервного копирования питания" встроенное микропрограммное обеспечение могло бы все еще играть его небезопасный и сохранить данные незаписанными некоторое время, дольше, чем один будет ожидать (так как в типичных вариантах использования оно не должно создавать проблемы).

• Вы могли бы хотеть считать данные прежде, чем записать новый блок и сравнить его, только удостовериться, что это действительно работает (и используйте очищенный буфер для чтения, если Вы достаточно параноики).

Существует много проблем с Вашим тестом, некоторые нечеткие, некоторые нет. Это также зависит от Вашей цели. Два тонких, вид нечетких проблем:

• Вы не читаете из той же области, в которую Вы пишете, Ваш тест чтения эффективно, затем, ничего не делает (если контроллер не читал, нарушают исправление, в этом случае это может иногда перемещать страницу, прочитанную в где-то в другом месте, но это все еще не влияет на Ваш тест).
• Вы принимаете (и это вероятно, но не гарантируемое), что чтение-запись к сбойному блоку обнаруживает и сообщает контроллер - Вы хотели бы записать данные, считать их назад и сравнить их для гарантируемой проверки.

Однако это возможно педантично. Более серьезный:

• Вы не можете использовать badblocks показать Вам привело страницы к сбою на флэш-памяти; все обнаружения отказов и последующие отображения страницы сделаны контроллером и очевидны для ОС. Вы могли получить некоторую информацию от УМНОГО, если поддержка дисков, это (я не знаю ни о каких SD-картах, которые поддерживают его, возможно, существуют карты флэш-памяти более высокого качества, которые делают).
• Выравнивание износа, осложненное Вашим тестом, не принимающим во внимание предшествующие команды ДЛЯ ОБРЕЗКИ, освобождать/использовать состояние диска во время теста и зарезервированное пространство.

Износ, Выравнивающийся: основной вопрос - то, что износ, выравнивающийся, является главной переменной в Вашем тесте. Это происходит на контроллере (обычно), и в любом случае его очевидные даже для прямого устройства ищут + чтение-запись. В Вашем примере Вы на самом деле не знаете состояние выравнивания износа (в частности, команды ДЛЯ ОБРЕЗКИ были недавно даны к свободным блокам?)...

Для динамического износа, выравнивающегося (существующий в фактически всех устройствах хранения на уровне конечного пользователя) на Вашем устройстве, затем, это могло быть в любом состоянии: В одном экстремальном значении ни одна из страниц не отмечена как свободная, и таким образом, единственные страницы, с которыми должен работать контроллер, являются теми в зарезервированном пространстве (если таковые имеются). Обратите внимание, что, если там резервируется пространство на устройстве, оно должно будет перестать работать полностью, прежде чем Вы начнете гарантироваться сбои на записях страницы (предположение, что нет никаких других страниц, отмеченных как свободные остающиеся). В другом экстремальном значении каждая страница отмечена как свободная, в этом случае у Вас теоретически должна быть каждая страница на сбое устройства, прежде чем Вы начнете видеть отказы при записи.

Для статического износа, выравнивающегося (который SSD имеют тенденцию иметь, SD-карты имеют тенденцию не иметь, и карты флэш-памяти, варьируются): нет действительно никакого пути вокруг этого кроме повторной записи в каждую страницу на устройстве.

... Другими словами, существуют детали выравнивания износа, которые у Вас нет способа знать и конечно никакой способ управлять - особенно, используется ли динамический износ, выравнивающийся, используется ли статический износ, выравнивающийся, и сумма пространства, зарезервированного на устройстве для износа, выравнивающегося (который не является видимым прошлым контроллер [или драйвер в некоторых случаях, как M-Systems старый DiskOnChip]).

SLC/MLC: Что касается SLC по сравнению с MLC, это оказывает очень прямое влияние на пределы, которые Вы ожидали бы видеть, но общая процедура выравнивания износа и процедура тестирования являются тем же для обоих. Многие поставщики не публикуют, являются ли их устройства SLC или MLC для их более дешевых потребительских товаров, хотя любой флеш-накопитель, который требует 100k + предел цикла на страницу, является вероятным SLC (упрощенный компромисс является SLC = износостойкость, MLC = плотность).

Кэширование: Что касается кэширования, это немного сомнительно. На уровне ОС, в общем случае, конечно, fsync/fdatasync не гарантирует, что данные на самом деле записаны. Однако я думаю, что безопасно предположить, что это (или по крайней мере контроллер принял на себя обязательство делать так, т.е. запись не будут глотать в кэше), в этом случае, поскольку съемные диски обычно разрабатываются для шаблона общего использования, "извлекаются" (размонтирование> синхронизация) затем удаляют (отключение питания). В то время как мы не знаем наверняка, образованное предположение говорит, что безопасно предположить, что синхронизация гарантирует, что запись абсолютно произойдет, особенно в записи-> синхронизация-> чтение назад (если бы это не было, то диски были бы ненадежны после того, как извлекаются). Нет никакой другой команды вне 'синхронизации', которая может быть выпущена на, извлекаются.

В контроллере что-либо возможно, но предположение выше также включает предположение, что контроллер, по крайней мере, ничего не делает, "усложнил" достаточно для риска потерей данных после синхронизации. Возможно, что контроллер может, скажем, буферизовать и записи группы или не записать данные, если те же данные переписываются (ограниченно). В программе ниже, мы чередуемся между двумя различными блоками данных и выполняем синхронизацию перед чтением назад конкретно для нанесения поражения разумному механизму кэширования контроллера. Однако, конечно, нет никаких гарантий и никакого способа знать, но мы можем сделать разумные предположения на основе нормального использования этих устройств и нормальных/распространенных механизмов кэширования.

Тестирование:

К сожалению, истина, если Вы не знаете, что устройство не имеет никакого зарезервированного пространства и не делает статического выравнивания, нет никакого способа окончательно протестировать предел цикла определенной страницы. Однако самое близкое, которое можно получить, следующим образом (не предположите статический износ, выравнивающийся):

Первая вещь, которую необходимо сделать, заполнить всю карту данными. Это важно, и является основной переменной, которую оставили в Вашем исходном тесте. Это отмечает, столько же блокируется возможный, сколько используется кроме любого зарезервированного пространства (к которому у Вас нет способа получить доступ). Обратите внимание, что мы работаем со всем устройством (который это уничтожит все данные по), поскольку работающий с единственным разделом только влияет на одну определенную область на устройстве:

dd if=/dev/urandom bs=512k of=/dev/sdb conv=fsync oflag=sync

Если Вы - тип индикатора выполнения:

pv -pterb -s <device_size> /dev/urandom | dd bs=512k of=/dev/sdb conv=fsync oflag=sync

Править: Поскольку карты с 4 МБ стирают блоки, попробуйте это за более быструю запись:

dd if=/dev/urandom bs=4M of=/dev/sdb conv=fsync oflag=direct,sync iflag=fullblock

Затем, затем можно записать тестовую программу цикла следующим образом, использовав O_DIRECT и O_SYNC (и возможно параноидальное, избыточное использование fsync()) для вырезания как можно большей буферизации ОС и кэширования из изображения и, теоретически, пишут непосредственно в контроллер и ожидают, пока это не сообщает, что операция закончилась:

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <cstdlib>
#include <cstdio>
#include <cstring>

using namespace std;

static const int BLOCK_SIZE = 512;
static const int ALIGNMENT = 512;
static const int OFFSET = 1024 * ALIGNMENT; // 1024 is arbitrary


int main (int argc, char **argv) {

    if (argc != 2) {
        fprintf(stderr, "usage: %s device\n", argv[0]);
        return 1;
    }

    int d = open(argv[1], O_RDWR | O_DIRECT | O_SYNC);
    if (d == -1) {
        perror(argv[1]);
        return 1;
    }

    char *block[2], *buffer;
    int index = 0, count = -1;

    // buffers must be aligned for O_DIRECT.
    posix_memalign((void **)&(block[0]), ALIGNMENT, BLOCK_SIZE);
    posix_memalign((void **)&(block[1]), ALIGNMENT, BLOCK_SIZE);
    posix_memalign((void **)&buffer, ALIGNMENT, BLOCK_SIZE);

    // different contents in each buffer
    memset(block[0], 0x55, BLOCK_SIZE);
    memset(block[1], 0xAA, BLOCK_SIZE);

    while (true) {

        // alternate buffers
        index = 1 - index;

        if (!((++ count) % 100)) {
            printf("%i\n", count);
            fflush(stdout);
        }

        // write -> sync -> read back -> compare
        if (lseek(d, OFFSET, SEEK_SET) == (off_t)-1)
            perror("lseek(w)");
        else if (write(d, block[index], BLOCK_SIZE) != BLOCK_SIZE)
            perror("write");
        else if (fsync(d))
            perror("fsync");
        else if (lseek(d, OFFSET, SEEK_SET) == (off_t)-1)
            perror("lseek(r)");
        else if (read(d, buffer, BLOCK_SIZE) != BLOCK_SIZE)
            perror("read");
        else if (memcmp(block[index], buffer, BLOCK_SIZE))
            fprintf(stderr, "memcmp: test failed\n");
        else
            continue;

        printf("failed after %i successful cycles.\n", count);
        break;

    }

}

Отметьте это O_DIRECT, буферы должны быть соответственно выровненные. 512-байтовые границы обычно достаточны. Можно скомпилировать с:

g++ -O0 test.cpp -o test

Добавить -D_POSIX_C_SOURCE=200112L при необходимости.

Затем после заполнения устройства полностью как выше, просто оставьте работавшим ночь:

./test /dev/sdb

512 байтов, выровненные записи прекрасны, который даст Вам одну всю страницу, стертую и переписанную. Вы могли значительно ускорить тест при помощи большего размера блока, но затем это становится сложным для прибытия в конкретные результаты.

Я в настоящее время тестирую на довольно потрепано выглядящей карте флэш-памяти PNY на 4 ГБ, которую я вчера нашел на тротуаре (казалось, был тем, что оставили http://www3.pny.com/4GB-Micro-Sleek-Attach---Purple-P2990C418.aspx).

Вышеупомянутая программа является по существу ограниченной версией badblocks и Вы не видели бы отказы, пока все зарезервированное пространство не было исчерпано. Поэтому ожидание (с 1 страницей, записанной на повторение), состоит в том, что вышеупомянутая процедура, в среднем, должна перестать работать в reserved_page_count * write_cycle_limit повторения (снова, износ, выравнивающийся, является главной переменной). Это - слишком плохие карты флэш-памяти, и SD-карты обычно не поддерживают УМНЫЙ, который имеет способность сообщить о зарезервированном размере пространства.

Между прочим, fsync по сравнению с fdatasync не имеет никакого значения для блочного устройства, пишет, что Вы делаете в целях этого теста. Ваш open() режимы важны.

Если Вам любопытно на предмет технических деталей; вот все, плюс что Вы могли бы хотеть знать (больше) о внутренних работах SD-карт: https://www.sdcard.org/downloads/pls/simplified_specs/part1_410.pdf

Править: Байты по сравнению со Страницами: В контексте этих типов тестов важно думать о вещах с точки зрения страниц, не байтов. Может быть очень неправильно сделать противоположное. Например, на SanDisk 8 ГБ SD, размер страницы согласно контроллеру (доступный через /sys/classes/mmc_host/mmc?/mmc?:????/preferred_erase_size) полные 4 МБ. Запись 16 МБ (выровненный к границам 4 МБ), затем, стирает/пишет 4 страницы. Однако при записи четырем единственным байтам каждый при смещениях 4 МБ друг от друга также стирает/пишет 4 страницы.

Это неточно, затем чтобы сказать, что "Я протестировал с записями 16 МБ", поскольку это - тот же объем износа как, "Я протестировал с 4 побайтовыми записями". Более точно, "Я протестировал с записями на 4 страницы".