В общем возникла такая проблема. Некоторое приложение записывает в файл, асинхронно, N Gb данных, после этого диспетчер задач windows показывает, что размер системного кэша ровно N Gb и он не освобождается. Что не так?

показывай как пишешь в файл (я так полагаю, речь не о системном кэше, а о своп-файле [файле подкачки])

нет, именно о системном кэше, не о своп файле

ну, тогда пробуй выключить буферизацию: FILE_FLAG_NO_BUFFERING

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

если есть желание, можешь так же использовать физическую память, если важна скорость: AllocateUserPhysicalPages, MapUserPhysicalPages, FreeUserPhysicalPages

Добавлено через 3 минуты и 49 секунд

в смысле и адрес и размер блока, передаваемые в Red/WriteFile должны быть кратны размеру сектора (если это условие не выполняется, функции вернут ошибку)

актуально только если файл открыт с флагом FILE_FLAG_NO_BUFFERING

Я думал пробовал, но мне нужно писать данные именно асинхронно... то есть с флагом FILE_FLAG_OVERLAPPED

и в чем проблема? эти флаги не противоречат друг другу

вот простое чтение без буфера с задержкой

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

Добавлено через 2 минуты и 19 секунд
с записью точно так же

я так думаю надо flush сделать
или commit

flush делается 
в общем после выходных попробую))

Думаю поможет flush.
А вообще я не знаю как это в винде устроинно, а вот в Linux это не совсем запись в файл, ядро сохраняет некоторые данные в оперативе а потом когда небудь сохраняет на диск, это связано с производительностью, так как файл могут заново открыть, для синхронизации делается системные вызов sync() - да кажется так.)))

В общем, проблема никуда не делась. Запись в файл без буферизации я сделать не могу, так-как в один файл у меня пишут несколько экземпляров одной программы, синхронизируя доступ к нему. В случае эксклюзивного доступа к файлу это решает проблему, но я не могу придумать алгоритм записи в файл нескольких приложений для случая, когда за один write можно записать 512*n байт, притом, что каждая программа записывает данные блоками по N байт, причем N - переменная величина. 
Файл я открываю так:


причем, если FILE_SHARE_READ убрать, то проблема исчезает, но в этом случае нельзя читать данные во время записи, что то-же важно.

На сколько N - переменная величина? Значение этой величины может различаться между разными экземплярами программы?
Если да, то нет смысла писать все это в один файл, проще выделить для каждого процесса свой файл,
либо разделить однородные данные в разных файлах, т.е. зафиксировать за каждым файлом свое N. Тогда можно использовать следующий расчет:

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

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

Проблема оказалась глубже чем я думал, вот код, который ее иллюстрирует:

эта программа просто пишет в файл, синхронно, при этом, файл открыт для записи и к тому-же система позволит открыть этот файл для записи и для чтения другому процессу. 
Что-бы наблюдать утечку памяти, нужно запустить эту программу, при этом, она начнет писать данные в файл. Системный кэш расти при этом не будет. Но, если открыть этот файл чем нибудь еще, даже просто для просмотра(я пробовал это делать TotalCommander-ом и FAR-ом, а так-же утилитой grep) системный кэш начнет расти, причем ровно настолько, сколько данных записано в файл. Если после того, как вы открыли файл на просмотр программа запишет гигабайт данных в файл, то размер системного кэша увеличится на гигабайт - железно, при этом, если не будет хватать памяти, будет выгружено все что только может быть выгружено  . Причем эта память не освобождается до тех пор, пока файл не будет закрыт всеми приложениями, открывшими его.
Короче это какой-то .... мне нужно именно в таком режиме его записывать, в общем, я не знаю что делать...

Это сообщение отредактировал(а) Lazin - 3.12.2008, 11:32

FILE_FLAG_SEQUENTIAL_SCAN -  флаг для последовательного доступа
а при FILE_SHARE_READ|FILE_SHARE_WRITE доступ к файлу из чужих процессов уже явно не последовательный
т.е. тут нужно скорее всего выбрать что-то одно: либо скорость эксклюзивного доступа, либо интерактивность с чужими процессами

по крайней мере это логично, когда система отменяет влияние флага FILE_FLAG_SEQUENTIAL_SCAN и начинает кэшировать данные, когда файл последовательно не читается