Форум: "Прочее";
Текущий архив: 2013.07.28;
Скачать: [xml.tar.bz2];
Вниз
Ребят, потестите пожалуйста Найти похожие ветки
← →
DVM © (2013-02-13 17:19) [40]
> 1) принципиально различаются чтение и запись. У тебя насколько
> понял всё в одном
Да, в одном классе, разумеется
> 2) для файлов существуют отдельные "классы". Специально
> заточенные, чтобы больше не париться
У меня вообще нет привязки к источнику/приемнику данных, это декоратор.
> 3) у тебя насколько понял есть только Read() и Write().
не, не только, Flush, например, тоже есть, я и не ставил целью достичь максимума возможного, мне нужна была максимальная гибкость.
> особенно если object хранится на стеке.
где то читал, что все уже в куче хранится.
← →
DevilDevil © (2013-02-13 17:19) [41]> dmk ©
круто, спасибо
тут было высказано предложение делать FlushFileBuffers для чистоты эксперимента
только я не умею
← →
DVM © (2013-02-13 17:21) [42]
> DevilDevil © (13.02.13 17:09) [37]
> я чёт не понял. а в чём там ошибка то ?
в том, что левой части нельзя присвоить правую :)
← →
DevilDevil © (2013-02-13 17:24) [43]> DVM © (13.02.13 17:19) [40]
> не, не только, Flush, например, тоже есть, я и не ставил
> целью достичь максимума возможного, мне нужна была максимальная
> гибкость.
ну мне тоже нужна гибкость. Только вместо TStream используется TCustomCachedBuffer.
кстати нет особой сложности реализовать ридер или райтер, использующий TStream. Нужно лишь реализовать соответствующий калбек. Я прост не первый день борюсь за производительность, такой подход немного эффективней )
> где то читал, что все уже в куче хранится.
это наверное если New/Dispose использовать. У меня их нет. В бенчмарке - на стеке. А в дизассемблере - прямое обращение к переменным стека
← →
DevilDevil © (2013-02-13 17:26) [44]> в том, что левой части нельзя присвоить правую :)
звучит как бред :)
разберись пожалуйста, почему XE2 ругается
← →
DVM © (2013-02-13 17:27) [45]
> > я чёт не понял. а в чём там ошибка то ?
вот здесь про записи, у тебя object, но разницы нету:
http://stackoverflow.com/questions/5484163/delphi-e2064-left-side-cannot-be-assigned-to-error-appeared-when-upgrading-a-p
← →
DVM © (2013-02-13 17:38) [46]
> DVM © (13.02.13 17:27) [45]
тьфу, не ту ссылку прислал, вот правильная:
http://stackoverflow.com/questions/6676083/using-for-in-sentence-and-compiler-error-e2064
← →
DevilDevil © (2013-02-13 17:39) [47]> DVM © (13.02.13 17:27) [45]
with теперь не работает со структурами ?
← →
DVM © (2013-02-13 17:40) [48]
> with теперь не работает со структурами ?
>
>
не, смотри следующее мое сообщение
← →
DVM © (2013-02-13 17:42) [49]
> DevilDevil © (13.02.13 17:39) [47]
Если коротко, то компилятор не дает тебе обратиться к полю объекта, который возможно еще не создан. Если ты попытаешься сначала прочитать значение поля, а потом записать туда, то копилятор не будет против такой конструкции (ну там по ссылке второй расписано)
← →
DevilDevil © (2013-02-13 17:47) [50]> DVM © (13.02.13 17:42) [49]
не радует меня такая фишка. бред
к тому же что, if (State =) не считается чтением ?
← →
DVM © (2013-02-13 17:48) [51]
> DevilDevil © (13.02.13 17:39) [47]
в твоем случае, можно вероятно как то так:
function FuncThreadFinalizing(Parameter: pointer): integer;
var
Obj: TCachedBufferThreadMemory;
begin
Obj := PCachedBufferThreadMemory(Parameter)^;
with Obj do
begin
if (State = STATE_DONE) then State := STATE_FINALIZE;
Result := State;
end;
end;
← →
Павиа (2013-02-13 18:09) [52]Бред какойто.
1) Скорость измеряется в МБайт/с
2) Во вторых непонятно какой алгоритм записи тестируем.
3) Кто же тестирует без учёта кэша?
4) Зачем грузить систему вторым поток, если можно асинхронно писать?
Автору рано такое писать. Он ничего незнает и знать не хочет.
← →
Игорь Шевченко © (2013-02-13 19:43) [53]Павиа (13.02.13 18:09) [52]
Это ты совсем не по теме наехал
← →
DevilDevil © (2013-02-13 19:49) [54]> 3) Кто же тестирует без учёта кэша?
> 4) Зачем грузить систему вторым поток, если можно асинхронно писать?
исходники отрыты, милости прошу редактировать
← →
Sapersky (2013-02-13 21:32) [55]Насчёт кэша Павиа прав, другое дело, какой результат считать более близким к жизни - с кэшем или без. Для чтения вроде как критичен первый запуск, но сейчас есть Superfetch, который заранее грузит наиболее используемые файлы. Для записи всё работает с первого раза, если не писать постоянно со скоростью, превышающей возможности диска.
Зато результаты без кэша можно по крайней мере сравнить с характеристиками диска.
Вот результаты чтения с кэшем и без (после /). Кэш сбрасывал утилитой RamMap (Empty standby list), также отключил Superfetch. Вообще лучше использовать FILE_FLAG_NO_BUFFERING в самом тесте, но там нужно спец. выранивание буферов и т.п.
1) "Standard TStringList reader"... 5437 / 6735ms
2) "Fast buffering reader"... 718ms / 1657ms
3) "Using CachedFileReader"... 563ms / 953ms
4) "Using CachedFileReader+DoubleThreading"... 859ms / 891ms
900 ms - близко к реальной максимальной скорости диска (100-120 мб/c).
Не очень понятно, что здесь делает многопоточность (по коду вникать лень). Теоретически с обычным HDD попытки одновременно читать из разных мест ничего не ускорят, на практике получилось чуть быстрее, но м.б. это погрешность.
DVM © (13.02.13 17:48) [51]
Obj там должен быть указателем, иначе модифицируется локальная копия.
← →
DevilDevil © (2013-02-13 21:48) [56]> Sapersky (13.02.13 21:32) [55]
> Насчёт кэша Павиа прав
никто не спорит
я говорю - скажите что вставить, чтобы лучше тестировать
> Вообще лучше использовать FILE_FLAG_NO_BUFFERING
ok. Кстати. Будет ли негативно сказывать этот флаг, если файл кэшируется в ОС? Как узнать размер на который надо выравнивать ?
> Не очень понятно, что здесь делает многопоточность (по коду
> вникать лень).
в чём состоит моя идея
поправь если не прав
Запись (или чтение) на диск - достаточно затратная операция. Причём в этот момент проц почти не грузится, а мы тупо ждём работы HDD. Для повышения производительности я попробовал реализовать двойной буфер. Пока один буфер используется нами, второй взаимодействует с диском в дополнительном потоке. Потом синхронизируемся и свапим буфера
← →
Игорь Шевченко © (2013-02-13 22:08) [57]Sapersky (13.02.13 21:32) [55]
Пользователь кэш не отключает (я таких пользователей не видел, поэтому предполагаю, что это крайне нерегулярное явление). Чистые характеристики диска тоже никому не интересны, если диск меделенный, он будет медленный всегда и везде, и наоборот.
Совокупная скорость записи зависит от трех вещей - скорости заполнения буфера при записи, размера буфера и скорости обработки цепочкой драйверов запросов на запись. Так как на последнее влиять мягко скажем, не удастся, то остается варьировать в разумных пределах вторым звеном цепочки и в некоторых пределах первым.
Например, вызов System.Write 32 раза по 32 байта будет выполняться медленнее, чем вызов Windows.WriteFile с заранее подготовленным буфером размером 32*32 байта, вне зависимости от того, какого размера буфер установлен для файла, куда пишется System.Write, здесь срабатывает скорость заполнения буфера.
512 вызовов Windows.WriteFile с порцией для записи в 1К будут медленнее, чем один вызов Windows.WriteFile с 512К буфером, потому что запросы на ввод-вывод будут генерироваться чаще в 512 раз.
1 вызов Windows.WriteFile с порцией для записи в 32М будет медленнее, чем 64 вызова Windows.WriteFile с 512К буфером, и т.д.
И наконец, на RAMDrive запись может быть медленнее при прочих равных, чем на HDD или на SSD, потому что драйвер сам по себе медленно обрабатывает запросы на ввод/вывод, как бы это не казалось странным.
Вывод простой - серебряной пули нет.
← →
DevilDevil © (2013-02-13 22:15) [58]> Вывод простой - серебряной пули нет.
я заводил ветку здесь, опытным путём было определено, что оптимальный размер буфера - 256кб.
← →
Игорь Шевченко © (2013-02-13 22:30) [59]
unit Main;
interface
procedure Run;
implementation
uses
Windows, SysUtils, DateUtils;
const
SFileData: AnsiString = "123456789012345678901234567890"#13#10;
{$WARN SYMBOL_PLATFORM OFF}
procedure RunWriteFileTest (const AFileName: string; ABufferSizeKBytes: Integer);
function PrepareBuffer: PByte;
var
I, J: Integer;
Worker: PByte;
begin
Result := PByte(AllocMem(ABufferSizeKBytes * 1024));
Worker := Result;
for I := 1 to ABufferSizeKBytes do
for J := 1 to 32 do
begin
Move(PAnsiChar(SFileData)^, Worker^, 32);
Inc(Worker, 32);
end;
end;
var
Buf: PByte;
I: Integer;
BytesWritten: DWORD;
F: THandle;
begin
// Buffered WriteFile, write 512M file using prepared buffer
Buf := PrepareBuffer;
try
F := CreateFile(PChar(AFileName), GENERIC_WRITE, 0, nil, CREATE_NEW, 0, 0);
Win32Check(F <> INVALID_HANDLE_VALUE);
try
for I := 1 to (512 * 1024) div ABufferSizeKBytes do
Win32Check(WriteFile(F, Buf^, ABufferSizeKBytes * 1024, BytesWritten, nil) and
(BytesWritten = DWORD(ABufferSizeKBytes * 1024)));
finally
CloseHandle(F);
end;
finally
FreeMem(Buf);
end;
DeleteFile(AFileName);
end;
procedure RunWriteTest (const AFileName: string; ABufferSizeKBytes: Integer);
var
F: TextFile;
I, J: Integer;
Buf: Pointer;
begin
// Write 512M file using writeln by portions of 30bytes + CRLF, using pre-allocated buffer
Buf := AllocMem(ABufferSizeKBytes * 1024);
try
AssignFile(F, AFileName);
Rewrite(F);
SetTextBuf(F, Buf^, ABufferSizeKBytes*1024);
try
for I := 1 to 512 * 1024 do
for J := 1 to 32 do
write(F, SFileData);
finally
CloseFile(F);
end;
DeleteFile(AFileName)
finally
FreeMem(Buf);
end;
end;
procedure Run;
const BufferSizes: array[1..17] of Integer = (
1, 2, 4, 8, 16, 32, 64, 128,
256, 512, 1024, 2048, 4096, 8192, 16384, 32768,
65536);
var
StartTime, ElapsedTime: TDateTime;
Seconds: Integer;
I, K, Times: Integer;
begin
Times := 10;
for K in BufferSizes do
begin
StartTime := Now;
for I := 1 to Times do
RunWriteFileTest (Format("%dK.txt", [K]), K);
ElapsedTime := Now - StartTime;
Seconds := SecondOf(ElapsedTime);
writeln(Format("%d seconds to write 512M (WriteFile using %dK buffer) %d times", [Seconds, K, Times]));
end;
for K in BufferSizes do
begin
StartTime := Now;
for I := 1 to Times do
RunWriteTest (Format("%dK.txt", [K]), K);
ElapsedTime := Now - StartTime;
Seconds := SecondOf(ElapsedTime);
writeln(Format("%d seconds to write 512M (Write using %dK buffer) %d times", [Seconds, K, Times]));
end;
end;
end.14 seconds to write 512M (WriteFile using 1K buffer) 10 times
10 seconds to write 512M (WriteFile using 2K buffer) 10 times
7 seconds to write 512M (WriteFile using 4K buffer) 10 times
4 seconds to write 512M (WriteFile using 8K buffer) 10 times
3 seconds to write 512M (WriteFile using 16K buffer) 10 times
2 seconds to write 512M (WriteFile using 32K buffer) 10 times
2 seconds to write 512M (WriteFile using 64K buffer) 10 times
2 seconds to write 512M (WriteFile using 128K buffer) 10 times
2 seconds to write 512M (WriteFile using 256K buffer) 10 times
2 seconds to write 512M (WriteFile using 512K buffer) 10 times
2 seconds to write 512M (WriteFile using 1024K buffer) 10 times
2 seconds to write 512M (WriteFile using 2048K buffer) 10 times
2 seconds to write 512M (WriteFile using 4096K buffer) 10 times
2 seconds to write 512M (WriteFile using 8192K buffer) 10 times
3 seconds to write 512M (WriteFile using 16384K buffer) 10 times
22 seconds to write 512M (WriteFile using 32768K buffer) 10 times
32 seconds to write 512M (WriteFile using 65536K buffer) 10 times
24 seconds to write 512M (Write using 1K buffer) 10 times
20 seconds to write 512M (Write using 2K buffer) 10 times
19 seconds to write 512M (Write using 4K buffer) 10 times
16 seconds to write 512M (Write using 8K buffer) 10 times
14 seconds to write 512M (Write using 16K buffer) 10 times
13 seconds to write 512M (Write using 32K buffer) 10 times
13 seconds to write 512M (Write using 64K buffer) 10 times
13 seconds to write 512M (Write using 128K buffer) 10 times
12 seconds to write 512M (Write using 256K buffer) 10 times
12 seconds to write 512M (Write using 512K buffer) 10 times
12 seconds to write 512M (Write using 1024K buffer) 10 times
12 seconds to write 512M (Write using 2048K buffer) 10 times
12 seconds to write 512M (Write using 4096K buffer) 10 times
13 seconds to write 512M (Write using 8192K buffer) 10 times
13 seconds to write 512M (Write using 16384K buffer) 10 times
33 seconds to write 512M (Write using 32768K buffer) 10 times
44 seconds to write 512M (Write using 65536K buffer) 10 times
HDD: ST2000DL003
← →
DevilDevil © (2013-02-14 00:25) [60]> Игорь Шевченко © (13.02.13 22:30) [59]
хороший тест
но
1) обычно время мериют миллисекундами. Самый плохой способ GetTockCount. Но он лучше чем Now
2) что-то не совсем верится. За 2 секунды записать 5Гб
3) что если использовать FILE_FLAG_NO_BUFFERING
4) надо бы выложить сразу exe-шник, чтобы можно было потестить
← →
Игорь Шевченко © (2013-02-14 00:34) [61]DevilDevil © (14.02.13 00:25) [60]
> 1) обычно время мериют миллисекундами. Самый плохой способ
> GetTockCount. Но он лучше чем Now
Обычно меряют rdtsc.
Не нравятся секунды - там множитель стоит, его можно убрать и мерить в тиках. Первоначальные изменения были как раз в тиках, только скорость тоже высокая получалась, перешел на секунды и на множитель.
> 2) что-то не совсем верится. За 2 секунды записать 5Гб
Вот это меня и смущает. Менеджер кэша работает быстро, но чтобы настолько - это странно.
> 4) надо бы выложить сразу exe-шник, чтобы можно было потестить
Выкладываю dpr, можно собрать, там сложностей нет.program FileWriteSpeed;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils,
Main in "Main.pas";
begin
try
Run;
except
on E: Exception do
Writeln(E.ClassName, ": ", E.Message);
end;
end.
> 3) что если использовать FILE_FLAG_NO_BUFFERING
Нецелесообразно
← →
Игорь Шевченко © (2013-02-14 00:47) [62]Все эти тесты целесообразно проводить, наблюдая выдачу утилит от Sysinternals и параллельно запуская профайлер, тот же AQTime, чтобы было видно, какая часть времени на что тратится и в какие действия системы (в частности, в какие IRP) выливаются те или иные конструкции прикладной программы или вызовы API.
← →
DevilDevil © (2013-02-14 09:28) [63]> Игорь Шевченко © (14.02.13 00:47) [62]
> Все эти тесты целесообразно проводить, наблюдая выдачу утилит
> от Sysinternals и параллельно запуская профайлер, тот же
> AQTime, чтобы было видно, какая часть времени на что тратится
> и в какие действия системы (в частности, в какие IRP) выливаются
> те или иные конструкции прикладной программы или вызовы
> API.
Что я могу сказать. В плане заполнения и чтения буфера, CachedBuffers не имеет равных, как минимум среди более-менее стандартных средств. Потому что он построен так, чтобы иметь максимально быстрый доступ к буферу.
На данный момент меня больше всего беспокоит вопрос грамотного обращения с диском, чтобы выжать максимум. В данном случае это и есть слабое место
(нужно понимать, как лучше всего читать с диска. и писать на диск. А так же понять, как эту эффективность можно замерить)
← →
DVM © (2013-02-14 10:21) [64]
> Sapersky (13.02.13 21:32) [55]
> DVM © (13.02.13 17:48) [51]
> Obj там должен быть указателем, иначе модифицируется локальная
> копия.
Да, действительно:
function FuncThreadFinalizing(Parameter: pointer): integer;
var
Obj: PCachedBufferThreadMemory;
begin
Obj := PCachedBufferThreadMemory(Parameter);
with Obj^ do
begin
if (State = STATE_DONE) then State := STATE_FINALIZE;
Result := State;
end;
end;
Такая конструкция компилятор устраивает, как оно реально будет работать не проверял.
← →
DevilDevil © (2013-02-14 12:24) [65]господа, давайте активизироваться с идеями
максимально производительного доступа к диску
и способами замера такой производительности
← →
Владислав © (2013-02-14 13:23) [66]
> Игорь Шевченко © (14.02.13 00:34) [61]
> > 2) что-то не совсем верится. За 2 секунды записать 5Гб
>
>
> Вот это меня и смущает. Менеджер кэша работает быстро, но
> чтобы настолько - это странно.
Flush не хватает.
А еще SecondOf возвращает количество секунд от 0 до 59.
Немного переделал твой вариант. Вот что получилось на моем HDD ST3500418AS.С Flush
6443 ms to write 512M (WriteFile using 1K buffer) 1 times
5210 ms to write 512M (WriteFile using 2K buffer) 1 times
5460 ms to write 512M (WriteFile using 4K buffer) 1 times
5101 ms to write 512M (WriteFile using 8K buffer) 1 times
4743 ms to write 512M (WriteFile using 16K buffer) 1 times
4602 ms to write 512M (WriteFile using 32K buffer) 1 times
4571 ms to write 512M (WriteFile using 64K buffer) 1 times
4742 ms to write 512M (WriteFile using 128K buffer) 1 times
4727 ms to write 512M (WriteFile using 256K buffer) 1 times
4664 ms to write 512M (WriteFile using 512K buffer) 1 times
4634 ms to write 512M (WriteFile using 1024K buffer) 1 times
4695 ms to write 512M (WriteFile using 2048K buffer) 1 times
4821 ms to write 512M (WriteFile using 4096K buffer) 1 times
4960 ms to write 512M (WriteFile using 8192K buffer) 1 times
4868 ms to write 512M (WriteFile using 16384K buffer) 1 times
4914 ms to write 512M (WriteFile using 32768K buffer) 1 times
4773 ms to write 512M (WriteFile using 65536K buffer) 1 times
154441 ms to write 512M (no buf WriteFile using 4K buffer) 1 times
79701 ms to write 512M (no buf WriteFile using 8K buffer) 1 times
41559 ms to write 512M (no buf WriteFile using 16K buffer) 1 times
23057 ms to write 512M (no buf WriteFile using 32K buffer) 1 times
16146 ms to write 512M (no buf WriteFile using 64K buffer) 1 times
12184 ms to write 512M (no buf WriteFile using 128K buffer) 1 times
10639 ms to write 512M (no buf WriteFile using 256K buffer) 1 times
9906 ms to write 512M (no buf WriteFile using 512K buffer) 1 times
8720 ms to write 512M (no buf WriteFile using 1024K buffer) 1 times
8253 ms to write 512M (no buf WriteFile using 2048K buffer) 1 times
5990 ms to write 512M (no buf WriteFile using 4096K buffer) 1 times
5788 ms to write 512M (no buf WriteFile using 8192K buffer) 1 times
4758 ms to write 512M (no buf WriteFile using 16384K buffer) 1 times
4976 ms to write 512M (no buf WriteFile using 32768K buffer) 1 times
4712 ms to write 512M (no buf WriteFile using 65536K buffer) 1 times
5054 ms to write 512M (no buf WriteFile using 131072K buffer) 1 times
4774 ms to write 512M (no buf WriteFile using 262144K buffer) 1 times
4820 ms to write 512M (no buf WriteFile using 524288K buffer) 1 times
74990 ms to write 512M (Write using 1K buffer) 1 times
73320 ms to write 512M (Write using 2K buffer) 1 times
73695 ms to write 512M (Write using 4K buffer) 1 times
73867 ms to write 512M (Write using 8K buffer) 1 times
74240 ms to write 512M (Write using 16K buffer) 1 times
73898 ms to write 512M (Write using 32K buffer) 1 times
74116 ms to write 512M (Write using 64K buffer) 1 times
73758 ms to write 512M (Write using 128K buffer) 1 times
74287 ms to write 512M (Write using 256K buffer) 1 times
74101 ms to write 512M (Write using 512K buffer) 1 times
74334 ms to write 512M (Write using 1024K buffer) 1 times
Без Flush
2746 ms to write 512M (WriteFile using 1K buffer) 1 times
1170 ms to write 512M (WriteFile using 2K buffer) 1 times
920 ms to write 512M (WriteFile using 4K buffer) 1 times
406 ms to write 512M (WriteFile using 8K buffer) 1 times
312 ms to write 512M (WriteFile using 16K buffer) 1 times
577 ms to write 512M (WriteFile using 32K buffer) 1 times
250 ms to write 512M (WriteFile using 64K buffer) 1 times
234 ms to write 512M (WriteFile using 128K buffer) 1 times
686 ms to write 512M (WriteFile using 256K buffer) 1 times
234 ms to write 512M (WriteFile using 512K buffer) 1 times
234 ms to write 512M (WriteFile using 1024K buffer) 1 times
1514 ms to write 512M (WriteFile using 2048K buffer) 1 times
265 ms to write 512M (WriteFile using 4096K buffer) 1 times
296 ms to write 512M (WriteFile using 8192K buffer) 1 times
531 ms to write 512M (WriteFile using 16384K buffer) 1 times
2465 ms to write 512M (WriteFile using 32768K buffer) 1 times
3229 ms to write 512M (WriteFile using 65536K buffer) 1 times
150978 ms to write 512M (no buf WriteFile using 4K buffer) 1 times
78062 ms to write 512M (no buf WriteFile using 8K buffer) 1 times
40779 ms to write 512M (no buf WriteFile using 16K buffer) 1 times
23385 ms to write 512M (no buf WriteFile using 32K buffer) 1 times
15647 ms to write 512M (no buf WriteFile using 64K buffer) 1 times
12324 ms to write 512M (no buf WriteFile using 128K buffer) 1 times
9578 ms to write 512M (no buf WriteFile using 256K buffer) 1 times
9579 ms to write 512M (no buf WriteFile using 512K buffer) 1 times
8673 ms to write 512M (no buf WriteFile using 1024K buffer) 1 times
8331 ms to write 512M (no buf WriteFile using 2048K buffer) 1 times
6099 ms to write 512M (no buf WriteFile using 4096K buffer) 1 times
5226 ms to write 512M (no buf WriteFile using 8192K buffer) 1 times
5055 ms to write 512M (no buf WriteFile using 16384K buffer) 1 times
4664 ms to write 512M (no buf WriteFile using 32768K buffer) 1 times
4415 ms to write 512M (no buf WriteFile using 65536K buffer) 1 times
4649 ms to write 512M (no buf WriteFile using 131072K buffer) 1 times
4758 ms to write 512M (no buf WriteFile using 262144K buffer) 1 times
4181 ms to write 512M (no buf WriteFile using 524288K buffer) 1 times
75270 ms to write 512M (Write using 1K buffer) 1 times
74335 ms to write 512M (Write using 2K buffer) 1 times
73757 ms to write 512M (Write using 4K buffer) 1 times
73944 ms to write 512M (Write using 8K buffer) 1 times
74116 ms to write 512M (Write using 16K buffer) 1 times
73867 ms to write 512M (Write using 32K buffer) 1 times
73664 ms to write 512M (Write using 64K buffer) 1 times
← →
Владислав © (2013-02-14 13:27) [67]"no buf WriteFile using " это с флагом FILE_FLAG_NO_BUFFERING.
> Игорь Шевченко © (14.02.13 00:34) [61]
Интересно. Твой тест:
3 seconds to write 512M (WriteFile using 16384K buffer) 10 times
22 seconds to write 512M (WriteFile using 32768K buffer) 10 times
Мой тест:
531 ms to write 512M (WriteFile using 16384K buffer) 1 times
2465 ms to write 512M (WriteFile using 32768K buffer) 1 times
У тебя тоже кэш диска 16 МБ? :)
← →
DevilDevil © (2013-02-14 15:09) [68]> Владислав © (14.02.13 13:23) [66]
>4571 ms to write 512M (WriteFile using 64K buffer) 1 times
получается оптимальный размер для записи 64кб.
какая у тебя ОС кстати ?
похоже это размер сектора
можешь потестировать с FILE_FLAG_NO_BUFFERING и другими указанными тобой флагами ?
← →
Игорь Шевченко © (2013-02-14 18:45) [69]Продолжаем поиски серебряной пули...
В оба варианта моего проекта добавлен вызов FlushFileBuffers, чтобы время доступа к диску было более приемлемым. Измерение скорости выполнено в миллисекундах.
Результаты:
HDD ST3000VX00061671 milliseconds to write 512M (WriteFile using 1K buffer and flush) 10 times
average speed is 83,02 Mb per second
56515 milliseconds to write 512M (WriteFile using 2K buffer and flush) 10 times
average speed is 90,60 Mb per second
53359 milliseconds to write 512M (WriteFile using 4K buffer and flush) 10 times
average speed is 95,95 Mb per second
51989 milliseconds to write 512M (WriteFile using 8K buffer and flush) 10 times
average speed is 98,48 Mb per second
51359 milliseconds to write 512M (WriteFile using 16K buffer and flush) 10 times
average speed is 99,69 Mb per second
49785 milliseconds to write 512M (WriteFile using 32K buffer and flush) 10 times
average speed is 102,84 Mb per second
47507 milliseconds to write 512M (WriteFile using 64K buffer and flush) 10 times
average speed is 107,77 Mb per second
41578 milliseconds to write 512M (WriteFile using 128K buffer and flush) 10 times
average speed is 123,14 Mb per second
38431 milliseconds to write 512M (WriteFile using 256K buffer and flush) 10 times
average speed is 133,23 Mb per second
37517 milliseconds to write 512M (WriteFile using 512K buffer and flush) 10 times
average speed is 136,47 Mb per second
36331 milliseconds to write 512M (WriteFile using 1024K buffer and flush) 10 times
average speed is 140,93 Mb per second
35018 milliseconds to write 512M (WriteFile using 2048K buffer and flush) 10 times
average speed is 146,21 Mb per second
34068 milliseconds to write 512M (WriteFile using 4096K buffer and flush) 10 times
average speed is 150,29 Mb per second
33748 milliseconds to write 512M (WriteFile using 8192K buffer and flush) 10 times
average speed is 151,71 Mb per second
33334 milliseconds to write 512M (WriteFile using 16384K buffer and flush) 10 times
average speed is 153,60 Mb per second
36456 milliseconds to write 512M (WriteFile using 32768K buffer and flush) 10 times
average speed is 140,44 Mb per second
34382 milliseconds to write 512M (WriteFile using 65536K buffer and flush) 10 times
average speed is 148,92 Mb per second
70368 milliseconds to write 512M (Write using 1K buffer and flush) 10 times
average speed is 72,76 Mb per second
65331 milliseconds to write 512M (Write using 2K buffer and flush) 10 times
average speed is 78,37 Mb per second
63093 milliseconds to write 512M (Write using 4K buffer and flush) 10 times
average speed is 81,15 Mb per second
61048 milliseconds to write 512M (Write using 8K buffer and flush) 10 times
average speed is 83,87 Mb per second
60412 milliseconds to write 512M (Write using 16K buffer and flush) 10 times
average speed is 84,75 Mb per second
59725 milliseconds to write 512M (Write using 32K buffer and flush) 10 times
average speed is 85,73 Mb per second
55658 milliseconds to write 512M (Write using 64K buffer and flush) 10 times
average speed is 91,99 Mb per second
51288 milliseconds to write 512M (Write using 128K buffer and flush) 10 times
average speed is 99,83 Mb per second
49588 milliseconds to write 512M (Write using 256K buffer and flush) 10 times
average speed is 103,25 Mb per second
47676 milliseconds to write 512M (Write using 512K buffer and flush) 10 times
average speed is 107,39 Mb per second
46793 milliseconds to write 512M (Write using 1024K buffer and flush) 10 times
average speed is 109,42 Mb per second
44979 milliseconds to write 512M (Write using 2048K buffer and flush) 10 times
average speed is 113,83 Mb per second
43733 milliseconds to write 512M (Write using 4096K buffer and flush) 10 times
average speed is 117,07 Mb per second
44161 milliseconds to write 512M (Write using 8192K buffer and flush) 10 times
average speed is 115,94 Mb per second
43346 milliseconds to write 512M (Write using 16384K buffer and flush) 10 times
average speed is 118,12 Mb per second
48728 milliseconds to write 512M (Write using 32768K buffer and flush) 10 times
average speed is 105,07 Mb per second
45770 milliseconds to write 512M (Write using 65536K buffer and flush) 10 times
average speed is 111,86 Mb per second
← →
Игорь Шевченко © (2013-02-14 18:47) [70]SSD INTEL_SSDSA2M160G2GC
16382 milliseconds to write 512M (WriteFile using 1K buffer and flush) 1 times
average speed is 31,25 Mb per second
12268 milliseconds to write 512M (WriteFile using 2K buffer and flush) 1 times
average speed is 41,73 Mb per second
8902 milliseconds to write 512M (WriteFile using 4K buffer and flush) 1 times
average speed is 57,52 Mb per second
7215 milliseconds to write 512M (WriteFile using 8K buffer and flush) 1 times
average speed is 70,96 Mb per second
9802 milliseconds to write 512M (WriteFile using 16K buffer and flush) 1 times
average speed is 52,23 Mb per second
5875 milliseconds to write 512M (WriteFile using 32K buffer and flush) 1 times
average speed is 87,15 Mb per second
7754 milliseconds to write 512M (WriteFile using 64K buffer and flush) 1 times
average speed is 66,03 Mb per second
10311 milliseconds to write 512M (WriteFile using 128K buffer and flush) 1 times
average speed is 49,66 Mb per second
5840 milliseconds to write 512M (WriteFile using 256K buffer and flush) 1 times
average speed is 87,67 Mb per second
7652 milliseconds to write 512M (WriteFile using 512K buffer and flush) 1 times
average speed is 66,91 Mb per second
5460 milliseconds to write 512M (WriteFile using 1024K buffer and flush) 1 times
average speed is 93,77 Mb per second
5731 milliseconds to write 512M (WriteFile using 2048K buffer and flush) 1 times
average speed is 89,34 Mb per second
7762 milliseconds to write 512M (WriteFile using 4096K buffer and flush) 1 times
average speed is 65,96 Mb per second
5103 milliseconds to write 512M (WriteFile using 8192K buffer and flush) 1 times
average speed is 100,33 Mb per second
7576 milliseconds to write 512M (WriteFile using 16384K buffer and flush) 1 times
average speed is 67,58 Mb per second
5261 milliseconds to write 512M (WriteFile using 32768K buffer and flush) 1 times
average speed is 97,32 Mb per second
7899 milliseconds to write 512M (WriteFile using 65536K buffer and flush) 1 times
average speed is 64,82 Mb per second
18333 milliseconds to write 512M (Write using 1K buffer and flush) 1 times
average speed is 27,93 Mb per second
10755 milliseconds to write 512M (Write using 2K buffer and flush) 1 times
average speed is 47,61 Mb per second
9397 milliseconds to write 512M (Write using 4K buffer and flush) 1 times
average speed is 54,49 Mb per second
10584 milliseconds to write 512M (Write using 8K buffer and flush) 1 times
average speed is 48,37 Mb per second
8517 milliseconds to write 512M (Write using 16K buffer and flush) 1 times
average speed is 60,12 Mb per second
7000 milliseconds to write 512M (Write using 32K buffer and flush) 1 times
average speed is 73,14 Mb per second
8749 milliseconds to write 512M (Write using 64K buffer and flush) 1 times
average speed is 58,52 Mb per second
6726 milliseconds to write 512M (Write using 128K buffer and flush) 1 times
average speed is 76,12 Mb per second
8092 milliseconds to write 512M (Write using 256K buffer and flush) 1 times
average speed is 63,27 Mb per second
7304 milliseconds to write 512M (Write using 512K buffer and flush) 1 times
average speed is 70,10 Mb per second
6830 milliseconds to write 512M (Write using 1024K buffer and flush) 1 times
average speed is 74,96 Mb per second
6324 milliseconds to write 512M (Write using 2048K buffer and flush) 1 times
average speed is 80,96 Mb per second
8997 milliseconds to write 512M (Write using 4096K buffer and flush) 1 times
average speed is 56,91 Mb per second
6333 milliseconds to write 512M (Write using 8192K buffer and flush) 1 times
average speed is 80,85 Mb per second
5914 milliseconds to write 512M (Write using 16384K buffer and flush) 1 times
average speed is 86,57 Mb per second
6776 milliseconds to write 512M (Write using 32768K buffer and flush) 1 times
average speed is 75,56 Mb per second
6412 milliseconds to write 512M (Write using 65536K buffer and flush) 1 times
average speed is 79,85 Mb per second
← →
Игорь Шевченко © (2013-02-14 18:49) [71]Изменения в коде:
unit ElapsedTimer;
interface
type
TElapsedTimer = class
private
FStarted: Boolean;
FPerformanceFrequency: int64;
FStartCounter: int64;
FStopCounter: int64;
function GetElapsedMilliseconds: Integer;
public
constructor Create;
procedure Start;
procedure Stop;
property ElapsedMilliseconds: Integer read GetElapsedMilliseconds;
end;
implementation
uses
Windows;
{ TElaspedTimer }
constructor TElapsedTimer.Create;
begin
QueryPerformanceFrequency(FPerformanceFrequency);
end;
function TElapsedTimer.GetElapsedMilliseconds: Integer;
begin
Result := (FStopCounter - FStartCounter) * 1000 div FPerformanceFrequency;
end;
procedure TElapsedTimer.Start;
begin
FStarted := True;
QueryPerformanceCounter(FStartCounter);
end;
procedure TElapsedTimer.Stop;
begin
Assert(FStarted);
QueryPerformanceCounter(FStopCounter);
FStarted := False;
end;
end.unit Main;
interface
procedure Run;
implementation
uses
Windows, SysUtils, ElapsedTimer;
const
SFileData: AnsiString = "123456789012345678901234567890"#13#10;
{$WARN SYMBOL_PLATFORM OFF}
procedure RunWriteFileTest(const AFileName: string; ABufferSizeKBytes: Integer);
function PrepareBuffer: PByte;
var
I, J: Integer;
Worker: PByte;
begin
Result := PByte(AllocMem(ABufferSizeKBytes * 1024));
Worker := Result;
for I := 1 to ABufferSizeKBytes do
for J := 1 to 32 do
begin
Move(PAnsiChar(SFileData)^, Worker^, 32);
Inc(Worker, 32);
end;
end;
var
Buf: PByte;
I: Integer;
BytesWritten: DWORD;
F: THandle;
begin
// Buffered WriteFile, write 512M file using prepared buffer
Buf := PrepareBuffer;
try
F := CreateFile(PChar(AFileName), GENERIC_WRITE, 0, nil, CREATE_NEW, 0, 0);
Win32Check(F <> INVALID_HANDLE_VALUE);
try
for I := 1 to (512 * 1024) div ABufferSizeKBytes do
Win32Check(WriteFile(F, Buf^, ABufferSizeKBytes * 1024, BytesWritten,
nil) and (BytesWritten = DWORD(ABufferSizeKBytes * 1024)));
finally
FlushFileBuffers(F);
CloseHandle(F);
end;
finally
FreeMem(Buf);
end;
DeleteFile(AFileName);
end;
procedure RunWriteTest(const AFileName: string; ABufferSizeKBytes: Integer);
var
F: TextFile;
I, J: Integer;
Buf: Pointer;
begin
// Write 512M file using writeln by portions of 30bytes + CRLF, using pre-allocated buffer
Buf := AllocMem(ABufferSizeKBytes * 1024);
try
AssignFile(F, AFileName);
Rewrite(F);
SetTextBuf(F, Buf^, ABufferSizeKBytes * 1024);
try
for I := 1 to 512 * 1024 do
for J := 1 to 32 do
write(F, SFileData);
finally
Flush(F);
FlushFileBuffers(TTextRec(F).Handle);
CloseFile(F);
end;
DeleteFile(AFileName)
finally
FreeMem(Buf);
end;
end;
procedure Run;
const
BufferSizes: array [1 .. 17] of Integer = (1, 2, 4, 8, 16, 32, 64, 128, 256,
512, 1024, 2048, 4096, 8192, 16384, 32768, 65536);
var
Timer: TElapsedTimer;
I, K, Times: Integer;
begin
Timer := TElapsedTimer.Create;
Times := 10;
for K in BufferSizes do
begin
Timer.Start;
for I := 1 to Times do
RunWriteFileTest(Format("%dK.txt", [K]), K);
Timer.Stop;
writeln(Format
("%d milliseconds to write 512M (WriteFile using %dK buffer and flush) %d times",
[Timer.ElapsedMilliseconds, K, Times]));
if Timer.ElapsedMilliseconds > 0 then
writeln(Format("average speed is %f Mb per second", [512*Times*1000 / Timer.ElapsedMilliseconds]));
end;
for K in BufferSizes do
begin
Timer.Start;
for I := 1 to Times do
RunWriteTest(Format("%dK.txt", [K]), K);
Timer.Stop;
writeln(Format
("%d milliseconds to write 512M (Write using %dK buffer and flush) %d times",
[Timer.ElapsedMilliseconds, K, Times]));
if Timer.ElapsedMilliseconds > 0 then
writeln(Format("average speed is %f Mb per second", [512*Times*1000 / Timer.ElapsedMilliseconds]));
end;
Timer.Free;
end;
end.
← →
Игорь Шевченко © (2013-02-14 18:52) [72]ну и выводы: буферизация да, в целом улучшает общее время.
Никаких
волшебных комбинаций настроек, скрываемых от общественности мудрецами из Microsoft не существует.
Надо улучшать производительность бизнес-задач в целом, а не рассматривать отдельные этапы.
← →
DevilDevil © (2013-02-14 22:33) [73]> Надо улучшать производительность бизнес-задач в целом, а
> не рассматривать отдельные этапы.
дисковые операции обычно самые затратные по времени
> Никаких волшебных комбинаций настроек, скрываемых от общественности
> мудрецами из Microsoft не существует.
так а ты же так и не попробовал FILE_FLAG_NO_BUFFERING, FILE_FLAG_SEQUENTIAL_SCAN, FILE_FLAG_WRITE_THROUGH
> QueryPerformanceCounter
говорят замер времени таким образом не совсем точный на многоядерных процессорах. Ибо стартовое время ты можешь засекать на одном ядре, а окончание - на другом. В моём игровом движке были проблемы с этим, на многоядерных машинах могло возвращаться отрицательное время. Известная проблема в общем. Лечится привязкой основного потока к конкретному ядру или использованием альтернативных функций
> F: TextFile;
я не совсем понял, за чем это
и вообще мне кажется надо убрать несколько явно проигрышных вариантов из теста - слишком длинный лог
← →
Игорь Шевченко © (2013-02-14 22:39) [74]DevilDevil © (14.02.13 22:33) [73]
> так а ты же так и не попробовал FILE_FLAG_NO_BUFFERING,
> FILE_FLAG_SEQUENTIAL_SCAN, FILE_FLAG_WRITE_THROUGH
Нецелесообразно. Очевидно, что с кэшем быстрее, чем без него.
← →
DevilDevil © (2013-02-14 22:53) [75]> FILE_FLAG_SEQUENTIAL_SCAN, FILE_FLAG_WRITE_THROUGH
мне кажется это вообще никак негативно не влияет на кеш, скорее наоборот позитивно
> FILE_FLAG_NO_BUFFERING
надо посмотреть как работает. в режиме кеша и в режиме flush
я думаю если буфер выровнен, и если есть такой особый режим - должны быть какие-то оптимизации
----------
я у себя не тестирую по двум причинам:
во-первых, у меня старое оборудование: и дома, и на работе. Т.е. не получу актуальных цифр
во-вторых, я не доверяю себе тестирование. Особенно когда являюсь разработчиком
← →
Игорь Шевченко © (2013-02-14 23:26) [76]то же самое, только без кэша:
HDD ST3000VX000 (64М внутренний кэш)41517 milliseconds to write 512M (WriteFile using 4K buffer, bypassing cache)
average speed is 12,33 Mb per second
21815 milliseconds to write 512M (WriteFile using 8K buffer, bypassing cache)
average speed is 23,47 Mb per second
12224 milliseconds to write 512M (WriteFile using 16K buffer, bypassing cache)
average speed is 41,88 Mb per second
7415 milliseconds to write 512M (WriteFile using 32K buffer, bypassing cache)
average speed is 69,05 Mb per second
5157 milliseconds to write 512M (WriteFile using 64K buffer, bypassing cache)
average speed is 99,28 Mb per second
4685 milliseconds to write 512M (WriteFile using 128K buffer, bypassing cache)
average speed is 109,28 Mb per second
4915 milliseconds to write 512M (WriteFile using 256K buffer, bypassing cache)
average speed is 104,17 Mb per second
4832 milliseconds to write 512M (WriteFile using 512K buffer, bypassing cache)
average speed is 105,96 Mb per second
4874 milliseconds to write 512M (WriteFile using 1024K buffer, bypassing cache) average speed is 105,05 Mb per second
6158 milliseconds to write 512M (WriteFile using 2048K buffer, bypassing cache) average speed is 83,14 Mb per second
5180 milliseconds to write 512M (WriteFile using 4096K buffer, bypassing cache) average speed is 98,84 Mb per second
3807 milliseconds to write 512M (WriteFile using 8192K buffer, bypassing cache) average speed is 134,49 Mb per second
3547 milliseconds to write 512M (WriteFile using 16384K buffer, bypassing cache) average speed is 144,35 Mb per second
3505 milliseconds to write 512M (WriteFile using 32768K buffer, bypassing cache) average speed is 146,08 Mb per second
3066 milliseconds to write 512M (WriteFile using 65536K buffer, bypassing cache) average speed is 166,99 Mb per second
3210 milliseconds to write 512M (WriteFile using 131072K buffer, bypassing cache)
average speed is 159,50 Mb per second
SSD31649 milliseconds to write 512M (WriteFile using 4K buffer, bypassing cache)
average speed is 16,18 Mb per second
23655 milliseconds to write 512M (WriteFile using 8K buffer, bypassing cache)
average speed is 21,64 Mb per second
16716 milliseconds to write 512M (WriteFile using 16K buffer, bypassing cache)
average speed is 30,63 Mb per second
13769 milliseconds to write 512M (WriteFile using 32K buffer, bypassing cache)
average speed is 37,18 Mb per second
10789 milliseconds to write 512M (WriteFile using 64K buffer, bypassing cache)
average speed is 47,46 Mb per second
9882 milliseconds to write 512M (WriteFile using 128K buffer, bypassing cache)
average speed is 51,81 Mb per second
8814 milliseconds to write 512M (WriteFile using 256K buffer, bypassing cache)
average speed is 58,09 Mb per second
8338 milliseconds to write 512M (WriteFile using 512K buffer, bypassing cache)
average speed is 61,41 Mb per second
7929 milliseconds to write 512M (WriteFile using 1024K buffer, bypassing cache) average speed is 64,57 Mb per second
8363 milliseconds to write 512M (WriteFile using 2048K buffer, bypassing cache) average speed is 61,22 Mb per second
8172 milliseconds to write 512M (WriteFile using 4096K buffer, bypassing cache) average speed is 62,65 Mb per second
4830 milliseconds to write 512M (WriteFile using 8192K buffer, bypassing cache) average speed is 106,00 Mb per second
9245 milliseconds to write 512M (WriteFile using 16384K buffer, bypassing cache) average speed is 55,38 Mb per second
4934 milliseconds to write 512M (WriteFile using 32768K buffer, bypassing cache) average speed is 103,77 Mb per second
7711 milliseconds to write 512M (WriteFile using 65536K buffer, bypassing cache) average speed is 66,40 Mb per second
6501 milliseconds to write 512M (WriteFile using 131072K buffer, bypassing cache)
average speed is 78,76 Mb per second
Видно, что SSD с мелкими порциями быстрее справляется
← →
Игорь Шевченко © (2013-02-14 23:28) [77]код
procedure RunWriteFileNoCacheTest(const AFileName: string;
ABufferSizeKBytes: Integer);
// Ensure allocated resgion is page-boundary alighed
function PrepareBuffer: PByte;
var
I, J: Integer;
Worker: PByte;
begin
Result := PByte(VirtualAlloc(nil, ABufferSizeKBytes * 1024,
MEM_RESERVE or MEM_COMMIT, PAGE_READWRITE));
Worker := Result;
for I := 1 to ABufferSizeKBytes do
for J := 1 to 32 do
begin
Move(PAnsiChar(SFileData)^, Worker^, 32);
Inc(Worker, 32);
end;
end;
var
Buf: PByte;
I: Integer;
BytesWritten: DWORD;
F: THandle;
begin
// Unbuffered WriteFile, write 512M file using prepared buffer
Buf := PrepareBuffer;
try
F := CreateFile(PChar(AFileName), GENERIC_WRITE, 0, nil, CREATE_NEW,
FILE_FLAG_NO_BUFFERING or FILE_FLAG_WRITE_THROUGH, 0);
Win32Check(F <> INVALID_HANDLE_VALUE);
try
for I := 1 to (512 * 1024) div ABufferSizeKBytes do
Win32Check(WriteFile(F, Buf^, ABufferSizeKBytes * 1024, BytesWritten,
nil) and (BytesWritten = DWORD(ABufferSizeKBytes * 1024)));
finally
CloseHandle(F);
end;
finally
VirtualFree(Buf, ABufferSizeKBytes * 1024, MEM_DECOMMIT or MEM_RELEASE);
end;
DeleteFile(AFileName);
end;
при сравнении как способа с FlushFileBuffers перед close, так и с обходом кэша, видно, что скорость работы приложения существенно медленнее.
Поэтому очевидный вывод о пользе кэша можно не оспаривать.
← →
DevilDevil © (2013-02-14 23:39) [78]> Игорь Шевченко © (14.02.13 23:28) [77]
так а ты же вроде не выравниваешь буфер на границу сектора О_о?
я у себя попробовал с выравнивание на 4кб и FILE_FLAG_NO_BUFFERING - у меня были ошибки с записью, вроде FileWrite возвращает не то значение
← →
Игорь Шевченко © (2013-02-14 23:52) [79]
> так а ты же вроде не выравниваешь буфер на границу сектора
> О_о?
> VirtualAlloc(nil, ABufferSizeKBytes * 1024,
> MEM_RESERVE or MEM_COMMIT, PAGE_READWRITE));
http://msdn.microsoft.com/ru-ru/library/windows/desktop/cc644950(v=vs.85).aspx
← →
Sapersky (2013-02-15 00:21) [80]говорят замер времени таким образом не совсем точный на многоядерных процессорах
Я читал, что в Висте/7 пофиксили, так что сейчас уже не особо актуально. Да и глюки были только со старыми AthlonX2, вроде.
FILE_FLAG_NO_BUFFERING - надо посмотреть как работает
Под "лучше использовать FILE_FLAG_NO_BUFFERING" я подразумевал - для теста, чтобы не сбрасывать кэш вручную. И скорее для чтения, чем для записи, на чтении больше вероятность, что кэш не сработает.
Запись (или чтение) на диск - достаточно затратная операция. Причём в этот момент проц почти не грузится, а мы тупо ждём работы HDD. Для повышения производительности я попробовал реализовать двойной буфер. Пока один буфер используется нами, второй взаимодействует с диском в дополнительном потоке.
Теоретически неплохая идея, при условии, что второй поток занят чем-то существенным, например, при загрузке текстового файла начинает парсинг предыдущего загруженного фрагмента, или в случае сжатых данных упаковкой/распаковкой.
Т.е. параллельно ввод-вывод и обработка. В тесте у тебя обработки как таковой нет, поэтому никакого эффекта не видно.
Интересно, можно ли получить какую-то выгоду от асинхронных операций, есть ли разница между просто вводом-выводом в отдельном потоке и асинхронными запросами.
Вот здесь товарищ получил:
http://blog.gamedeff.com/?p=142#more-142
хотя, конечно, задача у него сильно другая - случайное чтение с минимальными задержками. На последовательном, наверное, куча асинхронных запросов не поможет, разве что файл сильно фрагментирован.
Страницы: 1 2 3 4 5 вся ветка
Форум: "Прочее";
Текущий архив: 2013.07.28;
Скачать: [xml.tar.bz2];
Память: 0.71 MB
Время: 0.011 c
