Как разобрать текстовый файл в C # и быть связанным с io?
известно, что если вы читаете данные из диска, вы можете обработать / анализировать данные чтения гораздо быстрее, чем вы можете прочитать его диск.
Но эта распространенная мудрость (миф?) Не отражается моими тестами. Когда я прочитаю текстовый файл с двойным и и int в каждой строке, разделенную пространством, я намного медленнее, чем скорость моей физической диски (фактор 6). Текстовый файл выглядит так
1,1 0
2,1 1
3,1 2
Обновление Я включил PinVoke Performance, когда я делаю ReadFile с полным буфером в одном читании, чтобы получить «реальную» производительность.
- Производительность readfile - ReadfileIntobyteBuffer
- StringReader.Readline Performance Performance - CountLines
- StringReader.Readline небезопасно Perf - ParselicaUnsafe
- StringReader.read небезопасный Char Buf - ParseleneunsafechArbuf
- StringReader.Readline + Parsing Party Performance - Парсисея
Результаты представляют собой
Did native read 179,0MB in 0,4s, 484,2MB/s
Did read 10.000.000 lines in 1,6s, 112,7MB/s
Did parse and read unsafe 179,0MB in 2,3s, 76,5MB/s
Did parse and read unsafe char buf 179,0MB in 2,8s, 63,5MB/s
Did read and parse 179,0MB in 9,3s, 19,3MB/s
, хотя я пытался пропустить накладные расходы строковых конструкций в parselenesunsafecharbuf, это все еще довольно много медленнее, чем в версии, что выделяет новую строку каждый раз. Это все еще намного лучше, чем оригинальный 20 МБ с самым простым решением, но я думаю .NET должен быть в состоянии сделать лучше. Если уполномоченность логика для разбора строк, я получаю 258,8 МБ / с, что очень хорошее и возле собственной скорости. Но я не вижу способа использования небезопасного кода, чтобы сделать мой разбор намного проще. Я должен иметь дело с неполными линиями, что делает его довольно сложным.
Обновление Из числа ясно, что простая строка. Split уже слишком много стоит дорого. Но StringReader также стоит довольно много. Как выглядит высоко оптимизированное решение, которое становится ближе к реальной скорости диска? Я пробовал много способов с небезопасным кодом и буферами Char Buffers, но усиление производительности была, возможно, 30%, но ничего в порядке величин, которые мне не понадобится. Я был бы в порядке с скоростью разборки 100 МБ / с. Это должно быть достижено с управляемым кодом или я ошибаюсь?
Это невозможно с C # разбираться быстрее, чем я могу читать с моего жесткого диска? Это Intel Postville X25M. ЦП и старше Intel Dual Core. У меня есть 3 ГБ ОЗУ Windows 7 .NET 3.5 SP1 и .NET 4.
Но я видел те же результаты на нормальных жестких дисках. Линейная скорость чтения может составлять до 400 МБ / с с сегодняшними жесткими дисками. Подразумевает ли это, что я должен реструктурировать мои приложения для чтения данных по требованию, когда на самом деле это необходимо, вместо того, чтобы с нетерпением прочитать его в память по стоимости более высоких времен GC из-за увеличения графика объекта, который делает циклы GC намного дольше.
Я заметил , что если я моему управляемому приложению USESE более 500 МБ памяти становится гораздо менее отзывчивым. Основным фактором, способствующим составным фактором, кажется сложностью графика объекта. Поэтому он может быть лучше прочитать данные при необходимости. По крайней мере, это мой вывод текущих данных.
Вот код
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Diagnostics;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
using System.ComponentModel;
namespace IOBound
{
class Program
{
static void Main(string[] args)
{
string data = @"C:\Source\IOBound\NumericData.txt";
if (!File.Exists(data))
{
CreateTestData(data);
}
int MB = (int) (new FileInfo(data).Length/(1024*1024));
var sw = Stopwatch.StartNew();
uint bytes = ReadFileIntoByteBuffer(data);
sw.Stop();
Console.WriteLine("Did native read {0:F1}MB in {1:F1}s, {2:F1}MB/s",
bytes/(1024*1024), sw.Elapsed.TotalSeconds, MB / sw.Elapsed.TotalSeconds);
sw = Stopwatch.StartNew();
int n = CountLines(data);
sw.Stop();
Console.WriteLine("Did read {0:N0} lines in {1:F1}s, {2:F1}MB/s",
n, sw.Elapsed.TotalSeconds, MB / sw.Elapsed.TotalSeconds);
sw = Stopwatch.StartNew();
ParseLinesUnsafe(data);
sw.Stop();
Console.WriteLine("Did parse and read unsafe {0:F1}MB in {1:F1}s, {2:F1}MB/s",
MB, sw.Elapsed.TotalSeconds, MB / sw.Elapsed.TotalSeconds);
sw = Stopwatch.StartNew();
ParseLinesUnsafeCharBuf(data);
sw.Stop();
Console.WriteLine("Did parse and read unsafe char buf {0:F1}MB in {1:F1}s, {2:F1}MB/s",
MB, sw.Elapsed.TotalSeconds, MB / sw.Elapsed.TotalSeconds);
sw = Stopwatch.StartNew();
ParseLines(data);
sw.Stop();
Console.WriteLine("Did read and parse {0:F1}MB in {1:F1}s, {2:F1}MB/s",
MB, sw.Elapsed.TotalSeconds, MB / sw.Elapsed.TotalSeconds);
}
private unsafe static uint ReadFileIntoByteBuffer(string data)
{
using(var stream = new FileStream(data, FileMode.Open))
{
byte[] buf = new byte[200 * 1024 * 1024];
fixed(byte* pBuf = &buf[0])
{
uint dwRead = 0;
if (ReadFile(stream.SafeFileHandle, pBuf, 200 * 1000 * 1000, out dwRead, IntPtr.Zero) == 0)
{
throw new Win32Exception();
}
return dwRead;
}
}
}
private static int CountLines(string data)
{
using (var reader = new StreamReader(data))
{
string line;
int count = 0;
while ((line = reader.ReadLine()) != null)
{
count++;
}
return count;
}
}
unsafe private static void ParseLinesUnsafeCharBuf(string data)
{
var dobules = new List();
var ints = new List();
using (var reader = new StreamReader(data))
{
double d = 0;
long a = 0, b = 0;
int i = 0;
char[] buffer = new char[10*1000*1000];
int readChars = 0;
int startIdx = 0;
fixed(char *ln = buffer)
{
while ((readChars = reader.Read(buffer, startIdx, buffer.Length - startIdx)) != 0)
{
char* pEnd = ln + readChars + startIdx;
char* pCur = ln;
char* pLineStart = null;
while (pCur != pEnd)
{
a = 0;
b = 0;
while (pCur != pEnd && *pCur == '\r' || *pCur == '\n')
{
pCur++;
}
pLineStart = pCur;
while(pCur != pEnd && char.IsNumber(*pCur))
{
a = a * 10 + (*pCur++ - '0');
}
if (pCur == pEnd || *pCur == '\r')
{
goto incompleteLine;
}
if (*pCur++ == ',')
{
long div = 1;
while (pCur != pEnd && char.IsNumber(*pCur))
{
b += b * 10 + (*pCur++ - '0');
div *= 10;
}
if (pCur == pEnd || *pCur == '\r')
{
goto incompleteLine;
}
d = a + ((double)b) / div;
}
else
{
goto skipRest;
}
while (pCur != pEnd && char.IsWhiteSpace(*pCur))
{
pCur++;
}
if (pCur == pEnd || *pCur == '\r')
{
goto incompleteLine;
}
i = 0;
while (pCur != pEnd && char.IsNumber(*pCur))
{
i = i * 10 + (*pCur++ - '0');
}
if (pCur == pEnd)
{
goto incompleteLine;
}
dobules.Add(d);
ints.Add(i);
continue;
incompleteLine:
startIdx = (int)(pEnd - pLineStart);
Buffer.BlockCopy(buffer, (int)(pLineStart - ln) * 2, buffer, 0, 2 * startIdx);
break;
skipRest:
while (pCur != pEnd && *pCur != '\r')
{
pCur++;
}
continue;
}
}
}
}
}
unsafe private static void ParseLinesUnsafe(string data)
{
var dobules = new List();
var ints = new List();
using (var reader = new StreamReader(data))
{
string line;
double d=0;
long a = 0, b = 0;
int ix = 0;
while ((line = reader.ReadLine()) != null)
{
int len = line.Length;
fixed (char* ln = line)
{
while (ix < len && char.IsNumber(ln[ix]))
{
a = a * 10 + (ln[ix++] - '0');
}
if (ln[ix] == ',')
{
ix++;
long div = 1;
while (ix < len && char.IsNumber(ln[ix]))
{
b += b * 10 + (ln[ix++] - '0');
div *= 10;
}
d = a + ((double)b) / div;
}
while (ix < len && char.IsWhiteSpace(ln[ix]))
{
ix++;
}
int i = 0;
while (ix < len && char.IsNumber(ln[ix]))
{
i = i * 10 + (ln[ix++] - '0');
}
dobules.Add(d);
ints.Add(ix);
}
}
}
}
private static void ParseLines(string data)
{
var dobules = new List();
var ints = new List();
using (var reader = new StreamReader(data))
{
string line;
char[] sep = new char[] { ' ' };
while ((line = reader.ReadLine()) != null)
{
var parts = line.Split(sep);
if (parts.Length == 2)
{
dobules.Add( double.Parse(parts[0]));
ints.Add( int.Parse(parts[1]));
}
}
}
}
static void CreateTestData(string fileName)
{
FileStream fstream = new FileStream(fileName, FileMode.Create);
using (StreamWriter writer = new StreamWriter(fstream, Encoding.UTF8))
{
for (int i = 0; i < 10 * 1000 * 1000; i++)
{
writer.WriteLine("{0} {1}", 1.1d + i, i);
}
}
}
[DllImport("kernel32.dll", SetLastError = true)]
unsafe static extern uint ReadFile(SafeFileHandle hFile, [Out] byte* lpBuffer, uint nNumberOfBytesToRead, out uint lpNumberOfBytesRead, IntPtr lpOverlapped);
}
}