Нужен способ сортировки файла журнала 100 GB по дате [закрыто]

такой код полностью связан с тем, как быстро вы можете получить данные с диска. Файл просто никогда не может поместиться в кэше файловой системы, поэтому вы всегда ждете на диске, чтобы предоставить данные. Вы делаете довольно хорошо на 10 МБ / сек, оптимизация кода никогда не будет иметь заметного эффекта.

получить более быстрый диск. Дефрагментируйте тот, который у вас есть в качестве промежуточного шага.

короткий ответ-загрузите данные в реляционную базу данных, например Sql Express, создайте индекс и используйте решение на основе курсора, например DataReader, чтобы прочитать каждую запись и записать ее на диск.

Почему бы вам не попробовать этот относительно неизвестный инструмент от microsoft под названием С помощью средства LogParser. Он в основном позволяет выполнять SQL-запрос через CSV-файл (или любой другой форматированный текстовый файл).

избавляет вас от необходимости перекачивать его в базу данных, делать свой вид и откачивать его снова

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

• разделите вход на несколько частей, которые вписываются в память и могут быть отсортированы с помощью стандартных алгоритмов сортировки в памяти (например, 100 Мб или больше-вам нужно будет сохранить ~4 части в памяти сразу). Отсортируйте все части и запишите их обратно диск.

• прочитайте две части с диска (они оба отсортированы) и объедините их, что можно сделать, одновременно повторяя два входа. Напишите объединенный набор данных в другое место на диске. Обратите внимание, что вам не нужно читать весь часть в память-просто прочитайте его / напишите его в блоках, как вы идете.

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

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

лучший способ оптимизации разбора дат-это вообще не разбирать их.

Как даты в формате ISO 8601, вы можете просто сравнить их как строки. Разбор не требуется вообще.

Что касается сортировки, вы должны иметь возможность эффективно использовать тот факт, что он частично отсортирован. Одним из подходов может быть чтение файла и запись в отдельные файлы, разделенные по временным диапазонам, например, ежедневно или ежечасно. Если вы сделаете каждый файл достаточно маленьким, вы можете затем прочитайте их в память и отсортируйте, а затем просто объедините все файлы.

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

для сортировки вы можете реализовать сортировку на основе файлов:

1. открыть входной файл
2. читать файл строка за строкой
3. узнать дату как строку из строки
4. добавить строку в файл <date>.log

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

оставшейся задачей будет сортировка созданных файлов и, возможно, снова объедините файл.

мне нужно проанализировать даты для алгоритмов.

On * NIX, я обычно сначала преобразовывал даты во что-то простое, подходящее для сравнения текста, и делал это первым словом в строке. Слишком рано для создания объекта даты / времени. Моя обычная презентация даты YYYYMMDD-hhmmss.millis. Сделайте так, чтобы все файлы имели одинаковый формат даты.

Я до сих пор не знаю, как сортировать файл 100GB на 4GB свободной оперативной памяти, не делая этого вручную.

Как вы уже поняли, сортировка слиянием является единственным вариантом.

Итак, для меня задачи попадают в следующий шаг:

1. стремно преобразование, чтобы сделать даты сортировки. Сложность: чтение / запись последовательно 100GB.

2. разделите данные на куски полезного размера, например 1GB, и отсортируйте каждый кусок, используя простую быструю сортировку перед записью на диск. Сложность: чтение / запись последовательно 100GB; память для быстрая сортировка.

3. сортировка слиянием мелких файлов в один большой. Это можно сделать поэтапно, используя программу, которая берет два файла и объединяет их в новый. Сложность: чтение / запись последовательно 100Gb log (N) раз (где N-количество файлов). Требование к космосу HDD: 2 * 100GB (последнее слияние 2 файлов x 50GB в одиночный файл 100GB).

4. программа для автоматизации предыдущего шага: выберите два (например, самые маленькие) файла, запустите программу для сортировки-объедините их в новый файл удалите два исходных файла. Повторяйте до тех пор, пока количество файлов не превысит 1.

5. (необязательно) разделите отсортированный файл 100GB на более мелкие куски управляемого размера. В конце концов, вы собираетесь что-то с ними сделать. Пронумеруйте их последовательно или поместите метки первого и последнего времени в имя файла.

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

на Linux, что все выполнимо с shell/sort/awk / Perl, и я не думаю, что это проблема, чтобы написать все это на любом другом языке программирования. Это потенциально 4 программы , но все они довольно просты в коде.

предполагая, что ваш файл журнала имеет только 1-2% строк не в порядке, вы можете сделать один проход через полный журнал, опережая два файла: один файл, который находится в порядке, и другой файл, содержащий 1-2% строк, которые не в порядке. Затем отсортируйте неупорядоченные строки в памяти и выполните одно слияние ранее неупорядоченных строк со строками в порядке. Это будет намного быстрее, чем полное слияние, которое сделает намного больше проходов.

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

на самом деле у меня нет много идей о преобразовании даты, но вещи, которые я бы попытался использовать, чтобы сделать это:

1. база данных с индексом в столбце Дата (чтобы быть легко найти в этих данных после).
2. для вставки в эту базу используйте Bulk Insert.
3. и какой-то способ параллельного чтения (в think parallel LINQ был бы хорош и очень прост в использовании).
4. много терпения (самое главное/трудная вещь)

упреждающий комментарий: Мой ответ касается только подзадачи разбора значений времени даты.

DateTime.Parse содержит проверки всех возможных форматов дат. Если у вас есть формат fix, вы можете оптимизировать синтаксический анализ довольно хорошо. Простая оптимизация заключалась бы в непосредственном преобразовании символов:

class DateParserYyyyMmDd
{
    static void Main(string[] args)
    {
        string data = "2010-04-22";

        DateTime date = Parse(data);
    }

    struct Date
    {
        public int year;
        public int month;
        public int day;
    }

    static Date MyDate;

    static DateTime Parse2(string data)
    {
        MyDate.year = (data[0] - '0') * 1000 + (data[1] - '0') * 100 
            + (data[2] - '0') * 10 + (data[3] - '0');
        MyDate.month = (data[5] - '0') * 10 + (data[6] - '0');
        MyDate.day = (data[8] - '0') * 10 + (data[9] - '0');

        return new DateTime(MyDate.year, MyDate.month, MyDate.day);
    }
}

помимо того, что вы делаете (вероятно, предложение willw полезно), ваш разбор может быть выполнен по нескольким потокам при условии, что у вас есть несколько процессоров или процессорных ядер.

на самом деле не решение, но просто из интереса, один из способов сделать это так:

• сначала разбейте файл на файлы 1GB
• затем, читая 2 файла за раз, загрузите содержимое в список строк и отсортируйте его
• записать его обратно в отдельные файлы.

проблема в том, что вам нужно будет прочитать/записать 100 файлов на каждом проходе и сделать 100 проходов, чтобы убедиться, что данные отсортированы.

Если моя математика правильно: то есть 10 000 ГБ чтения и 10 000 ГБ записи, в среднем 10 МБ / сек, что составляет 20 000 000 сек, что 231 дней

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

вы можете попробовать реализовать алгоритм сортировки radix. Поскольку radix сканирует весь список последовательно и только несколько раз, это может помочь здесь предотвратить гигантское количество сканирований и запросов вашего файла 100 GB.

сортировка Radix предназначена для классификации записей каждой итерации по одной части. Эта часть может быть цифрой или дату как год, месяц, день. в этом случае вам даже не нужно преобразовывать строку в DateTime, вы можете преобразовать только определенную часть в int.

Edit:

для целей сортировки вы можете создать временный двоичный файл только с 2 столбцами: DateTime (DateTime.ToBinary () как Int64) и адрес строки в исходном файле (как Int64).

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

после завершения сортировки временного файла вы можете создать обратно полный сортированный журнал 100 ГБ файл.

Вау. Во-первых, это совершенно новый уровень документирования-obssession.

мой фактический edvice будет, попробуйте рассмотреть, насколько необходим этот файл на самом деле.

о сортировке, я понятия не имею, будет ли это работать или нет, но вы можете попытаться построить перечислитель, который возвращает данные непосредственно с жесткого диска (не сохраняя ничего, кроме нескольких указателей, возможно), а затем пытается использовать OrderBy LINQ, который также возвращает IEnumerator, который вы, надеюсь, можете Enamurate и сохранить непосредственно обратно на диск.

единственный вопрос заключается в том, сохраняет ли OrderBy что-либо в ОЗУ.

загрузите вкус Linux с USB И используйте команду while для чтения Папка. Используйте команды grep, фильтры и Каналы для разделения данных. Все это можно сделать в 3 строки сценария BASH. Grep будет разрывать данные в Никакое время. Я grepped через 7 миллионов строк за 45 секунд