Документация Engee

Справочные материалы

Ниже приведена подробная документация по типам и методам, предоставляемым пакетом InterProcessCommunication. Эту информацию также можно получить из REPL, введя символ ?, за которым следует имя метода или типа.

Семафоры

Именованные семафоры

Semaphore(name, value; perms=0o600, volatile=true) -> sem

создает новый именованный семафор, идентифицируемый строкой name вида "/somename" и начальным значением value. Возвращается экземпляр Semaphore{String}. Для указания прав доступа можно использовать ключевое слово perms . Ключевое слово volatile указывает, должен ли семафор быть отсоединен после финализации возвращаемого объекта.

Semaphore(name) -> sem

открывает существующий именованный семафор и возвращает экземпляр Semaphore{String}.

Чтобы отсоединить (удалить) постоянный именованный семафор, просто сделайте следующее:

rm(Semaphore, name)

Если семафор не существует, ошибка игнорируется. Однако для других ошибок выводится ошибка SystemError.

Для максимальной гибкости экземпляр именованного семафора также может быть создан с помощью следующего:

open(Semaphore, name, flags, mode, value, volatile) -> sem

где для flags могут быть заданы биты IPC.O_CREAT и IPC.O_EXCL, mode определяет предоставленные права доступа, value является начальным значением семафора, а volatile представляет собой логическое значение, указывающее, должен ли семафор быть отсоединен после финализации возвращаемого объекта sem. Значения mode и value игнорируются, если открыт существующий именованный семафор. Параметры разрешений в mode маскируются под umask процесса.

Анонимные семафоры

Анонимные семафоры поддерживаются объектами памяти, обеспечивающими необходимое хранение.

Semaphore(mem, value; offset=0, volatile=true) -> sem

инициализирует анонимный семафор, поддерживаемый объектом памяти mem с начальным значением value, и возвращает экземпляр Semaphore{typeof(mem)}. Можно использовать ключевое слово offset для указания адреса (в байтах) данных семафора относительно pointer(mem). Ключевое слово volatile указывает, должен ли семафор быть уничтожен после финализации возвращаемого объекта.

Semaphore(mem; offset=0) -> sem

выдает экземпляр Semaphore{typeof(mem)}, связанный с инициализированным анонимным семафором и поддерживаемым объектом памяти mem в относительном расположении (в байтах), заданном ключевым словом offset.

Количество байтов, необходимое для хранения анонимного семафора, задается с помощью sizeof(Semaphore), а анонимный семафор должен быть выровнен в памяти на величину, кратную размеру слова в байтах (то есть Sys.WORD_SIZE >> 3). Объекты памяти, используемые для хранения анонимного семафора, должны реализовывать два метода: pointer(mem) и sizeof(mem) для получения базового адреса и размера (в байтах) связанной памяти соответственно.

См. также описание post, wait, timedwait, trywait.

post(sem)

увеличивает значение семафора sem (разблокирует семафор). Если значение семафора после этого станет больше нуля, будет пробужден другой процесс или поток, заблокированный в вызове wait для этого семафора.

См. также описание Semaphore, wait, timedwait, trywait.

wait(sem)

уменьшает значение семафора sem (блокирует семафор). Если значение семафора больше нуля, уменьшение продолжается и функция немедленно возвращается. Если в данный момент семафор имеет нулевое значение, вызов блокируется до тех пор, пока либо не появится возможность выполнить уменьшение (т. е. значение семафора станет больше нуля), либо обработчик сигнала не прервет вызов (в этом случае будет выдан экземпляр исключения InterruptException). В случае непредвиденной ошибки может возникнуть ошибка SystemError .

См. также описание Semaphore, post, timedwait, trywait.

timedwait(sem, secs)

уменьшает значение семафора sem (блокирует семафор). Если значение семафора больше нуля, уменьшение продолжается и функция немедленно возвращается. Если в данный момент семафор имеет нулевое значение, вызов блокируется до тех пор, пока либо не появится возможность выполнить уменьшение (т. е. значение семафора станет больше нуля), либо не истечет ограничение в заданное количество секунд secs (в этом случае будет выдан экземпляр исключения TimeoutError), либо обработчик сигнала не прервет вызов (в этом случае будет выдан экземпляр исключения InterruptException).

См. также описание Semaphore, post, wait, trywait.

trywait(sem) -> boolean

предпринимает попытку немедленного уменьшения значения (блокировки) семафора sem с возвращением true в случае успеха. Если уменьшение не может быть выполнено сразу же, вызов возвращает false. В случае прерывания или непредвиденной ошибки возникает исключение (InterruptException или SystemError соответственно).

См. также описание Semaphore, post, wait, timedwait.

Общая память

SharedMemory(id, len; perms=0o600, volatile=true)

выдает новый объект общей памяти, идентифицируемый по id, размер которого равен len байт. Идентификатор id может быть строкой, начинающейся с символа '/', для создания объекта общей памяти POSIX или ключом IPC System V для создания сегмента общей памяти BSD System V. В последнем случае ключ может представлять собой IPC.PRIVATE, чтобы автоматически создать несуществующий сегмент общей памяти.

Используйте ключевое слово perms, чтобы указать предоставляемые права доступа. По умолчанию пользователю разрешено выполнять только чтение и запись.

Используйте ключевое слово volatile, чтобы указать, является общая память непостоянной или нет. Если память является постоянной, она будет доступна до явного уничтожения или перезагрузки системы. По умолчанию общая память уничтожается, если она больше не используется.

Чтобы получить существующий объект общей памяти, вызовите следующее:

SharedMemory(id; readonly=false)

где id — это идентификатор общей памяти (строка, ключ IPC или идентификатор IPC System V сегмента общей памяти System V, возвращаемый ShmId). Ключевому слову readonly можно задать значение true, если требуется доступ только для чтения. Обратите внимание, что можно вызвать метод shmid(obj) для получения идентификатора объекта общей памяти obj.

Некоторые методы расширены для объектов общей памяти. Если предположить, что shm является экземпляром SharedMemory, то:

pointer(shm)    # выдает базовый адрес общей памяти
sizeof(shm)     # выдает количество байтов общей памяти
shmid(shm)      # выдает идентификатор общей памяти

Чтобы убедиться, что объект общей памяти shm в конце концов будет уничтожен, вызовите следующее:

rm(shm)

См. также описание shmid и shmrm.

Получает идентификатор сегмента общей памяти System V

Следующие вызовы:

ShmId(id)                  -> id
ShmId(arr)                 -> id
ShmId(key, readlony=false) -> id

выдают идентификатор сегмента общей памяти System V, связанного со значением первого аргумента. id является идентификатором сегмента общей памяти, arr является массивом, присоединенным к сегменту общей памяти System V, а key является ключом, связанным с сегментом общей памяти. В последнем случае readlony можно задать значение true, чтобы запрашивать доступ только для чтения. В противном случае будет запрашиваться доступ для чтения и записи.

См. также описание shmid, shmget.

ShmInfo представляет собой структуру, используемую для хранения информации о сегменте общей памяти System V. Вызов ShmInfo(arg) эквивалентен shminfo(arg).

shmid(arg)

выдает идентификатор существующего объекта общей памяти POSIX или сегмент общей памяти Sytem V, идентифицируемый по arg или связанный с arg. Аргумент может представлять собой следующее:

  • Экземпляр SharedMemory

  • Экземпляр WrappedArray, содержимое которого хранится в общей памяти

  • Строка, начинающаяся с '/' (и без других '/') для идентификации объекта общей памяти POSIX

  • Экземпляр IPC.Key для указания ключа IPC System V, связанного с сегментом общей памяти. В этом случае необязательному второму аргументу readonly можно задать значение true, чтобы запрашивать доступ только для чтения. В противном случае будет запрашиваться доступ для чтения и записи

  • Экземпляр ShmId для указания сегмента общей памяти System V

См. также описание SharedMemory, shmrm.

Получает или создает сегмент общей памяти System V

Вызов:

shmget(key, siz, flg) -> id

выдает идентификатор сегмента общей памяти, связанного со значением аргумента key. Новый сегмент общей памяти, размер которого равен значению siz (возможно, округленному до кратного размера страницы памяти IPC.PAGE_SIZE), создается, если key имеет значение IPC.PRIVATE или key не является IPC.PRIVATE, сегмент общей памяти, соответствующий key, не существует, а IPC_CREAT указан в аргументе flg.

Аргументы:

  • key является ключом IPC System V, связанным с сегментом общей памяти.

  • siz задает размер (в байтах) сегмента общей памяти (может быть округлен до кратного размера страницы памяти).

  • flg представляет собой битовую комбинацию флагов. Наименее значимые 9 бит определяют разрешения, предоставленные владельцу, группе и другим. Эти биты имеют тот же формат и то же значение, что и аргумент mode chmod. Для создания нового сегмента можно задать бит IPC_CREAT. Если этот флаг не используется, shmget найдет сегмент, связанный с key, и проверит, есть ли у пользователя разрешение на доступ к этому сегменту. Бит IPC_EXCL можно задать дополнительно к IPC_CREAT, чтобы гарантировать, что этот вызов создаст сегмент. Если задан и IPC_EXCL, и IPC_CREAT, вызов завершится неудачей, если сегмент уже существует.

shmat(id, readonly) -> ptr

присоединяет сегмент общей памяти к адресному пространству вызывающего объекта. Аргумент id является идентификатором сегмента общей памяти. Логический аргумент readonly указывает, следует ли присоединять сегмент для доступа только для чтения. В противном случае сегмент присоединяется для доступа для чтения и записи и процесс должен иметь разрешения на чтение и запись для сегмента. Возвращаемое значение представляет собой указатель на доступ к сегменту общей памяти.

См. также описание shmdt, shmrm.

shmdt(ptr)

отсоединяет сегмент общей памяти System V от адресного пространства вызывающего объекта. Аргумент ptr является указателем, возвращенным предыдущим вызовом shmat().

См. также описание shmdt, shmget.

shmrm(arg)

удаляет общую память, связанную с arg. Если arg является именем, соответствующая именованная общая память POSIX будет отсоединена. Если arg является ключом или идентификатором сегмента общей памяти BSD, сегмент помечается как подлежащий уничтожению. Аргумент arg также может быть объектом SharedMemory.

Можно также вызвать метод rm для удаления существующего сегмента или объекта общей памяти. Есть несколько возможностей:

rm(SharedMemory, name)  # `name` идентифицирует объект общей памяти POSIX
rm(SharedMemory, key)   # `key` связан с сегментом общей памяти BSD
`id` является идентификатором сегмента общей памяти BSD
rm(shm)                 # `shm` является экземпляром `SharedMemory`

См. также описание SharedMemory, shmid, shmat.

shmctl(id, cmd, buf)

performs the control operation specified by cmd on the System V shared memory segment whose identifier is given in id. The buf argument is a byte array large enough to store a shmid_ds C structure.

See also shminfo, shmcfg and shmrm.

shmcfg(arg, perms) -> id

изменяет права доступа сегмента общей памяти IPC System V. Аргумент perms задает битовые флаги с новыми разрешениями. Первым аргументом arg может быть идентификатор сегмента общей памяти, общий массив, присоединенный к сегменту общей памяти, или ключ IPC System V, связанный с сегментом общей памяти. Во всех случаях возвращается идентификатор сегмента общей памяти.

См. также описание ShmId, shmget, shmctl и SharedMemory.

shminfo(arg) -> info

выводит сведения о сегменте общей памяти System V, который идентифицируется или связан с arg, которым может быть идентификатор сегмента общей памяти, общий массив, присоединенный к сегменту общей памяти, или ключ IPC System V, связанный с сегментом общей памяти.

См. также описание ShmInfo, ShmId, shmget, shmat, SharedMemory.

shminfo!(arg, info) -> info

перезаписывает info (экземпляр ShmInfo) сведениями о сегменте общей памяти System V, который идентифицируется или связан с arg. Подробные сведения см. в описании shminfo.

Сигналы

SigSet представляет структуру C sigset_t. Ее следует рассматривать как непрозрачную, ее содержимое хранится в виде кортежа целых чисел без знака, размер которых совпадает с размером sigset_t.

Схема стандартного использования выглядит так:

sigset = SigSet()
sigset[signum] -> boolean
sigset[signum] = boolean
fill!(sigset, boolean) -> sigset

где signum является номером сигнала, целым числом, большим или равным 1 и меньшим или равным IPC.SIGRTMAX. Сигналы реального времени имеют номер signum, так что IPC.SIGRTMIN ≤ signum ≤ IPC.SIGRTMAX

Неэкспортируемые методы:

IPC.sigfillset!(sigset)          # то же, что и fill!(signum, true)
IPC.sigemptyset!(sigset)         # то же, что и fill!(signum, false)
IPC.sigaddset!(sigset, signum)   # то же, что и sigset[signum] = true
IPC.sigdelset!(sigset, signum)   # то же, что и sigset[signum] = false
IPC.sigismember(sigset, signum)  # то же, что и sigset[signum]

SigAction является аналогом структуры C struct sigaction. Используется для указания действий, выполняемых процессом при получении сигнала. Если предположить, что sa является экземпляром SigAction, у него есть следующие поля:

sa.handler         # адрес обработчика сигналов
sa.mask            # маска блокируемых сигналов
sa.flags           # битовые флаги

где sa.handler — это адрес функции C (может быть SIG_IGN или SIG_DFL), вызываемой при получении сигнала. Функцию можно задать с помощью cfunction. Если IPC.SA_INFO не задан в sa.flags, сигнатура обработчика выглядит следующим образом:

function handler(signum::Cint)::Nothing

это функция, которая принимает один аргумент типа Cint и ничего не возвращает. Если IPC.SA_INFO не задан в sa.flags, сигнатура обработчика выглядит следующим образом:

function handler(signum::Cint, siginf::Ptr{SigInfo}, unused::Ptr{Cvoid})::Nothing

это функция, которая принимает три аргумента типа Cint, Ptr{SigInfo}, Ptr{Cvoid} соответственно и ничего не возвращает. См. описание SigInfo, содержащее сведения об аргументе siginf для обработчика.

Вызовите следующее:

sa = SigAction()

чтобы создать новую пустую структуру, или

sa = SigAction(handler, mask, flags)

чтобы указать все поля.

См. также SigInfo, sigaction и sigaction!.

SigInfo представляет структуру C siginfo_t. Ее следует рассматривать как непрозрачную, ее содержимое хранится в виде кортежа целых чисел без знака, размер которых совпадает с размером siginfo_t, но, в принципе, обработчик сигналов, установленный с флагом SA_SIGINFO, должен получать только указатель.

При заданном ptr, экземпляре Ptr{SigInfo}, полученном обработчиком сигналов, элементы соответствующей структуры C siginfo_t извлекаются следующим образом:

IPC.siginfo_signo(ptr)  # Номер сигнала.
IPC.siginfo_code(ptr)   # Код сигнала.
IPC.siginfo_errno(ptr)  # Если значение ненулевое, значение errno, связанное с этим
                        # сигналом.
IPC.siginfo_pid(ptr)    # Идентификатор отправляющего процесса.
IPC.siginfo_uid(ptr)    # Идентификатор реального пользователя отправляющего процесса.
IPC.siginfo_addr(ptr)   # Адрес инструкции, приводящей к ошибке.
IPC.siginfo_status(ptr) # Значение или сигнал выхода.
IPC.siginfo_band(ptr)   # Ленточное событие для SIGPOLL.
IPC.siginfo_value(ptr)  # Значение сигнала.

Эти методы небезопасны, так как они используют адрес напрямую. Поэтому они не экспортируются по умолчанию. В зависимости от контекста не все элементы siginfo_t имеют значение (кроме того, они могут быть определены как объединение и, таким образом, перекрываться в памяти). На данный момент доступны только те элементы, которые определены стандартом POSIX. Наконец, значение, заданное с помощью IPC.siginfo_value(ptr), представляет тип C union sigval (объединение C int и C void*). В Julia оно возвращается (и задается в sigqueue) как целое число, достаточно большое, чтобы представлять оба типа значений.

sigaction(signum) -> sigact

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

sigaction(signum, sigact)

устанавливает sigact (экземпляр SigAction) в качестве действия, выполняемого процессом при получении сигнала signum.

Обратите внимание, что signum не может быть ни SIGKILL, ни SIGSTOP.

См. также описание SigAction и sigaction!.

sigaction!(signum, sigact, oldact) -> oldact

устанавливает sigact в качестве действия, выполняемого процессом при получении сигнала signum, перезаписывает oldact предыдущим действием и возвращает его. Аргументы sigact и oldact являются экземплярами SigAction.

Дополнительные сведения см. в описании SigAction и sigaction.

sigpending() -> mask

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

См. также описание sigpending!.

sigpending!(mask) -> mask

перезаписывает маску (mask) набором ожидающих сигналов и возвращает ее аргумент.

См. также описание sigpending.

sigprocmask() -> cur

выдает текущий набор заблокированных сигналов. Чтобы изменить набор заблокированных сигналов, вызовите следующее:

sigprocmask(how, set)

с набором (set) маски SigSet и параметром how, который указывает, как интерпретировать set:

  • IPC.SIG_BLOCK: набор заблокированных сигналов — это объединение текущего набора и аргумента set.

  • IPC.SIG_UNBLOCK: сигналы в set удаляются из текущего набора заблокированных сигналов. Разрешается попытаться разблокировать сигнал, который не заблокирован.

  • IPC.SIG_SETMASK: набор заблокированных сигналов задан для аргумента set.

См. также описание sigprocmask!.

sigprocmask!(cur) -> cur

перезаписывает cur (экземпляр SigSet) текущим набором заблокированных сигналов и возвращает его. Чтобы изменить набор заблокированных сигналов, вызовите следующее:

sigprocmask!(how, set, old) -> old

изменяет набор заблокированных сигналов согласно how и set (см. описание sigprocmask), перезаписывает old (экземпляр SigSet) предыдущим набором заблокированных сигналов и возвращает old.

См. также описание sigprocmask.

sigqueue(pid, sig, val=0)

отправляет сигнал sig в процесс с идентификатором pid. Аргумент val является необязательным значением для присоединения к сигналу. Это значение представляет тип C union sigval (объединение C int и C void*). В Julia оно указывается как целое число, достаточно большое, чтобы представлять оба типа значений.

sigsuspend(mask)

временно заменяет маску сигнала вызывающего процесса на маску, заданную с помощью mask, а затем приостанавливает процесс до получения сигнала, действие которого заключается в вызове обработчика сигналов или завершении процесса.

Если сигнал завершает процесс, sigsuspend не возвращается. Если сигнал перехватывается, sigsuspend возвращается после возврата обработчика сигналов и маска сигнала восстанавливается до состояния, предшествующего вызову sigsuspend.

Невозможно заблокировать IPC.SIGKILL или IPC.SIGSTOP. Указание этих значений в маске не влияет на маску сигнала процесса.

sigwait(mask, timeout=Inf) -> signum

приостанавливает выполнение вызывающего потока до тех пор, пока один из сигналов, указанных в mask набора сигналов, не будет находиться в состоянии ожидания. Функция принимает сигнал (удаляет его из списка ожидающих сигналов) и возвращает номер сигнала signum.

Можно указать необязательный аргумент timeout, чтобы задать ограничение на время ожидания, пока один из сигналов не перейдет в состояние ожидания. timeout может быть вещественным числом для указания количества секунд или экземпляром TimeSpec. Если timeout имеет значение Inf (по умолчанию), предполагается, что время ожидания не ограничено. Если значение timeout меньше нуля или равно ему или если timeout имеет значение TimeSpec(0,0), методы выполняют опрос и сразу же возвращаются. Если в течение допустимого времени ожидания ни один из сигналов, указанных в mask набора сигналов не перейдет в режим ожидания, выдается исключение TimeoutError .

См. также описание sigwait!, TimeSpec, TimeoutError.

sigwait!(mask, info, timeout=Inf) -> signum

действует аналогично sigwait, но дополнительным аргументом info является экземпляр SigInfo для хранения информации о принятом сигнале, остальные аргументы те же, что и для метода sigwait.

Массивы, заключенные в оболочку

WrappedArray(mem, [T [, dims...]]; offset=0)

выдает массив Julia, элементы которого хранятся в объекте «память» mem. Аргумент T — это тип данных элементов возвращаемого массива, а аргументы dims указывают измерения массива. Если dims пропущен, результатом является вектор максимальной длины (с учетом смещения и размера объекта mem). Если T опущен, предполагается, что используется UInt8.

Можно использовать ключевое слово offset для указания адреса (в байтах) относительно pointer(mem), где хранится первый элемент массива.

Размер памяти, задаваемый с помощью mem, должен быть достаточным для хранения всех элементов (с учетом смещения), а выравнивание элементов в памяти должно быть кратно Base.datatype_alignment(T).

Вот другая возможность:

WrappedArray(mem, dec)

где mem — это объект «память», а dec — функция, отвечающая за декодирование типа и структуры массива, заданного объектом памяти. Декодер применяется к объекту памяти следующим образом:

dec(mem) -> T, dims, offset

при этом должен выдаваться тип данных T элементов массива, измерения dims массива и смещение первого элемента относительно pointer(mem).

Ограничения

Объект mem должен расширять методы pointer(mem) и sizeof(mem), которые должны соответственно выдавать базовый адрес памяти, предоставляемой mem, и количество доступных байтов. Кроме того, предполагается, что эта память будет доступна по крайней мере до тех пор, пока объект mem не будет удален сборщиком мусора.

Массивы общей памяти

WrappedArray(id, T, dims; perms=0o600, volatile=true)

создает новый заключенный в оболочку массив, элементы которого (и заголовок) хранятся в общей памяти, идентифицируемой по id (см. раздел о SharedMemory с описанием id и ключевых слов). Чтобы получить этот массив в другом процессе, просто сделайте следующее:

WrappedArray(id; readonly=false)

См. также описание

SharedMemory.

Служебные программы

TimeSpec(sec, nsec)

выдает экземпляр TimeSpec для целого числа секунд sec и целого числа наносекунд nsec с начала эпохи.

TimeSpec(sec)

выдает экземпляр TimeSpec для, возможно, дробного числа секунд sec с начала эпохи. Аргумент также может быть экземпляром TimeVal.

Вызовите now(TimeSpec), чтобы получить текущее время как экземпляр TimeSpec.

При сложении и вычитании с участием экземпляра TimeSpec выдается результат TimeSpec. Пример:

now(TimeSpec) + 3.4

выдает экземпляр TimeSpec с текущим временем плюс 3.4 с.

typemin(TimeSpec)
typemax(TimeSpec)

соответственно, выдает минимальное и максимальное нормированные значения времени для экземпляра TimeSpec.

TimeVal(sec, usec)

выдает экземпляр TimeVal для целого числа секунд sec и целого числа микросекунд usec с начала эпохи.

TimeVal(sec)

выдает экземпляр TimeVal с, возможно, дробным числом секунд sec с начала эпохи. Аргумент также может быть экземпляром TimeSpec.

Вызовите now(TimeVal), чтобы получить текущее время как экземпляр TimeVal.

При сложении и вычитании с участием экземпляра TimeVal выдается результат TimeVal. Пример:

now(TimeVal) + 3.4

выдает экземпляр TimeVal с текущим временем плюс 3.4 с.

typemin(TimeVal)
typemax(TimeVal)

соответственно, выдает минимальное и максимальное нормированные значения времени для экземпляра TimeVal.

clock_getres(id) -> ts

выдает разрешение (точность) указанных часов id. Результатом является экземпляр IPC.TimeSpec. Идентификатор часов id может иметь значение CLOCK_REALTIME или CLOCK_MONOTONIC (см. описание clock_gettime).

См. также описание clock_gettime, clock_settime, gettimeofday, nanosleep, IPC.TimeSpec и IPC.TimeVal.

clock_gettime(id) -> ts

выдает время указанных часов id. Результатом является экземпляр IPC.TimeSpec. Идентификатор часов id может иметь одно из следующих значений:

  • CLOCK_REALTIME: общесистемные часы, измеряющие реальное (т. е. физическое) время. На эти часы влияют периодические скачки системного времени (например, если системный администратор вручную переводит часы), а также инкрементные корректировки, выполняемые с помощью adjtime и NTP.

  • CLOCK_MONOTONIC: часы, которые нельзя настроить и которые показывают монотонное время с некоторой неопределенной начальной точки. На эти часы не влияют периодические скачки системного времени.

См. также описание clock_getres, clock_settime, gettimeofday, nanosleep, IPC.TimeSpec и IPC.TimeVal.

clock_settime(id, ts)

задает время указанного id часов как ts. Аргумент ts может быть экземпляром IPC.TimeSpec или количеством секунд. Идентификатор часов id может иметь значение CLOCK_REALTIME или CLOCK_MONOTONIC (см. описание clock_gettime).

См. также описание clock_getres, clock_gettime, gettimeofday, nanosleep, IPC.TimeSpec и IPC.TimeVal.

gettimeofday() -> tv

выдает текущее время как экземпляр IPC.TimeVal. Результат можно преобразовать в дробное число секунд путем вызова float(tv).

См. также описание IPC.TimeVal, nanosleep, clock_gettime.

nanosleep(t) -> rem

спит в течение t секунд с точностью до наносекунды и возвращает оставшееся время (в случае прерываний) как экземпляр IPC.TimeSpec. Аргумент может быть (дробным) числом секунд или экземпляром IPC.TimeSpec или IPC.TimeVal.

Метод sleep, предоставляемый Julia, имеет только миллисекундную точность.

См. также описание gettimeofday, IPC.TimeSpec и IPC.TimeVal.

umask(msk) -> old

задает в качестве маски создания файлового режима вызывающего процесса (umask) значение msk & 0o0777 (т. е. используются только биты разрешения файла в маске) и возвращает предыдущее значение маски.

См. также описание IPC.maskmode.

IPC.maskmode(mode)

возвращает биты IPC.MASKMODE для mode, преобразованные в тип C mode_t.

Константа IPC.MASKMODE = 0o777 представляет собой битовую маску для предоставленных прав доступа (обычно устанавливается 9 наименее значимых бит).

См. также описание umask.

Исключения

TimeoutError используется для выдачи исключения времени ожидания.