Eu preciso acessar um arquivo simultaneamente com vários segmentos. Isso precisa ser feito simultaneamente, sem serialização de thread por motivos de desempenho.

O arquivo em particular foi criado com o atributo de arquivo 'temporário' que incentiva o Windows a manter o arquivo no cache do sistema. Isso significa que, na maioria das vezes, o arquivo lido não chegará perto do disco, mas lerá a parte do arquivo do cache do sistema.

Ser capaz de acessar simultaneamente esse arquivo irá melhorar significativamente o desempenho de certos algoritmos no meu código.

Então, há duas perguntas aqui:

É possível que o Windows acesse simultaneamente o mesmo arquivo de threads diferentes?Se sim, como você fornece essa habilidade? Eu tentei criar o arquivo temporário e abrir o arquivo novamente para fornecer dois identificadores de arquivo, mas o segundo abrir não terá êxito.

Aqui está a criação:

FFileSystem := CreateFile(PChar(FFileName),
                          GENERIC_READ + GENERIC_WRITE,
                          FILE_SHARE_READ + FILE_SHARE_WRITE,
                          nil,
                          CREATE_ALWAYS,
                          FILE_ATTRIBUTE_NORMAL OR
                          FILE_FLAG_RANDOM_ACCESS OR
                          FILE_ATTRIBUTE_TEMPORARY OR
                          FILE_FLAG_DELETE_ON_CLOSE,
                          0);

Aqui está o segundo aberto:

FFileSystem2 := CreateFile(PChar(FFileName),
                          GENERIC_READ,
                          FILE_SHARE_READ,
                          nil,
                          OPEN_EXISTING,
                          FILE_ATTRIBUTE_NORMAL OR
                          FILE_FLAG_RANDOM_ACCESS OR
                          FILE_ATTRIBUTE_TEMPORARY OR
                          FILE_FLAG_DELETE_ON_CLOSE,
                          0);

Eu tentei várias combinações das bandeiras sem sucesso até agora. O segundo arquivo aberto sempre falha, com mensagens para o efeito que o arquivo não pode ser acessado como está em uso por outro processo.

Editar:

OK, mais algumas informações (eu estava esperando não me perder nas ervas daninhas aqui ...)

O processo em questão é um processo do servidor Win32 em execução no WinXP 64. Ele está mantendo grandes bancos de dados espaciais e gostaria de manter o máximo possível do banco de dados espacial na memória em uma estrutura de cache L1 / L2. L1 já existe. O L2 existe como um arquivo 'temporário' que permanece no cache do sistema do Windows (é um pouco um truque sujo, mas chega perto das limitações de memória do win32). Win64 significa que eu posso ter muita memória usada pelo cache do sistema para que a memória usada para armazenar o cache L2 conte para a memória do processo.

Múltiplos (potencialmente muitos) threads querem acessar simultaneamente as informações contidas no cache L2. Atualmente, o acesso é serializado, o que significa que um thread consegue ler seus dados enquanto a maioria (ou o restante) dos encadeamentos são bloqueados até a conclusão dessa operação.

O arquivo de cache L2 é gravado, mas fico feliz em serializar / intercalar globalmente operações de leitura e gravação, desde que eu possa executar leituras simultâneas.

Estou ciente de que há problemas potenciais de simultaneidade de threads, e estou ciente de que existem dezenas de maneiras de eliminar esse gato em outros contextos. Eu tenho este contexto particular e estou tentando determinar se há uma maneira de permitir o acesso simultâneo de leitura de thread dentro do arquivo e dentro do mesmo processo.

Outra abordagem que considerei seria dividir o cache L2 em vários arquivos temporários, em que cada arquivo serializa o acesso ao thread da mesma forma que o arquivo de cache L2 atual.

E sim, essa abordagem um pouco desesperada é porque o Delphi de 64 bits não estará conosco em breve :-(

Obrigado, Raymond.