numpy.memmap: фиктивное выделение памяти

Нет ничего «поддельного» в том, что вы создаете файлы размером 10 ТБ.

Вы запрашиваете массивы размера

2 ** 37 * 10 = 1374389534720 элементов

Тип 'i8' означает 8-байтовое (64-битное) целое число, поэтому ваш окончательный массив будет иметь размер

1374389534720 * 8 = 10995116277760 байт

or

10995116277760 / 1E12 = 10.99511627776 TB

Если у вас есть только 250 ГБ свободного места на диске, то как вы можете создать файл «10 ТБ»?

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

Например, на моей машине с Linux мне разрешено делать что-то вроде этого:

# I only have about 50GB of free space...
~$ df -h /
Filesystem     Type  Size  Used Avail Use% Mounted on
/dev/sdb1      ext4  459G  383G   53G  88% /

~$ dd if=/dev/zero of=sparsefile bs=1 count=0 seek=10T
0+0 records in
0+0 records out
0 bytes (0 B) copied, 0.000236933 s, 0.0 kB/s

# ...but I can still generate a sparse file that reports its size as 10 TB
~$ ls -lah sparsefile
-rw-rw-r-- 1 alistair alistair 10T Dec  1 21:17 sparsefile

# however, this file uses zero bytes of "actual" disk space
~$ du -h sparsefile
0       sparsefile

Попробуйте вызвать du -h для вашего файла np.memmap после его инициализации, чтобы увидеть, сколько фактического места на диске он использует.

Когда вы начнете фактически записывать данные в свой np.memmap файл, все будет в порядке, пока вы не превысите физическую емкость своего хранилища, после чего процесс завершится с Bus error. Это означает, что если вам нужно записать ‹ 250 ГБ данных в ваш массив np.memmap, то проблем может не быть (на практике это, вероятно, также будет зависеть от того, где вы записываете в массиве, и от того, является ли он основной строкой или столбцом).

Как процесс может использовать 10 ТБ виртуальной памяти?

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

Как проверить, достаточно ли места на диске для хранения всего массива np.memmap?

Я предполагаю, что вы хотите сделать это программно в Python.

1. Получите количество доступного свободного места на диске. В ответах на этот предыдущий вопрос SO приведены различные методы. Один из вариантов: os.statvfs:

   import os
   
   def get_free_bytes(path='/'):
       st = os.statvfs(path)
       return st.f_bavail * st.f_bsize
   
   print(get_free_bytes())
   # 56224485376
   

2. Определите размер вашего массива в байтах:

   import numpy as np
   
   def check_asize_bytes(shape, dtype):
       return np.prod(shape) * np.dtype(dtype).itemsize
   
   print(check_asize_bytes((2 ** 37 * 10,), 'i8'))
   # 10995116277760
   

3. Проверить, является ли 2. > 1.

Обновление. Существует ли "безопасный" способ размещения файла np.memmap, гарантирующий, что на диске будет зарезервировано достаточно места для хранения всего массива?

Одной из возможностей может быть использование fallocate для предварительного выделения дискового пространства, например:

~$ fallocate -l 1G bigfile

~$ du -h bigfile
1.1G    bigfile

Вы можете вызвать это из Python, например, используя subprocess.check_call:

import subprocess

def fallocate(fname, length):
    return subprocess.check_call(['fallocate', '-l', str(length), fname])

def safe_memmap_alloc(fname, dtype, shape, *args, **kwargs):
    nbytes = np.prod(shape) * np.dtype(dtype).itemsize
    fallocate(fname, nbytes)
    return np.memmap(fname, dtype, *args, shape=shape, **kwargs)

mmap = safe_memmap_alloc('test.mmap', np.int64, (1024, 1024))

print(mmap.nbytes / 1E6)
# 8.388608

print(subprocess.check_output(['du', '-h', 'test.mmap']))
# 8.0M    test.mmap

Я не знаю независимого от платформы способа сделать это с помощью стандартной библиотеки, но есть fallocate Модуль Python на PyPI, который должен работать на любой ОС на основе Posix.

Основываясь на ответе @ali_m, я наконец пришел к этому решению:

# must be called with the argumant marking array size in GB
import sys, numpy, tempfile, subprocess

size = (2 ** 27) * int(sys.argv[1])
tmp_primary = tempfile.NamedTemporaryFile('w+')
array = numpy.memmap(tmp_primary.name, dtype = 'i8', mode = 'w+', shape = size)
tmp = tempfile.NamedTemporaryFile('w+')
check = subprocess.Popen(['cp', '--sparse=never', tmp_primary.name, tmp.name])
stdout, stderr = check.communicate()
if stderr:
    sys.stderr.write(stderr.decode('utf-8'))
    sys.exit(1)
del array
tmp_primary.close()
array = numpy.memmap(tmp.name, dtype = 'i8', mode = 'r+', shape = size)
array[0] = 666
array[size-1] = 777
print('File: {}. Array size: {}. First cell value: {}. Last cell value: {}'.\
      format(tmp.name, len(array), array[0], array[size-1]))
while True:
    pass

Идея состоит в том, чтобы скопировать изначально сгенерированный разреженный файл в новый нормальный. Для этого используется cp с опцией --sparse=never.

Когда сценарий вызывается с управляемым параметром размера (скажем, 1 ГБ), массив сопоставляется с неразреженным файлом. Это подтверждается выводом команды du -h, который теперь показывает размер ~1 ГБ. Если памяти не хватает, скрипты завершаются с ошибкой:

cp: ‘/tmp/tmps_thxud2’: write failed: No space left on device