cape.cfdx.options.ulimitopts: System resource options

This module provides a class to access options relating to system resources. Specifically, this pertains to options usually set by ulimit from the command line.

The class provided in this module, ULimitOpts, is loaded in the "RunControl" section of the JSON file or main options interface.

class cape.cfdx.options.ulimitopts.ULimitOpts(*args, **kw)

Class for resource limit options

Call:
>>> opts = ULimitOpts(**kw)
Inputs:
kw: dict

Dictionary of system resource options

Outputs:
opts: ULimitOpts

System resource options interface

Versions:

  • 2015-11-10 @ddalle: v1.0 (ulimit)

  • 2022-10-31 @ddalle: v2.0; use OptionsDict

get_c(j=None, i=None, **kw)

Get core file size limit, ulimit -c

Call:
>>> c = opts.get_c(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
c: {None} | object

core file size limit, ulimit -c

get_core_file_size(j=None, i=None, **kw)

Get core file size limit, ulimit -c

Call:
>>> core_file_size = opts.get_core_file_size(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
core_file_size: {None} | object

value of option “core_file_size”

get_d(j=None, i=None, **kw)

Get process data segment limit, ulimit -d

Call:
>>> d = opts.get_d(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
d: {None} | object

process data segment limit, ulimit -d

get_data_segment(j=None, i=None, **kw)

Get process data segment limit, ulimit -d

Call:
>>> data_segment = opts.get_data_segment(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
data_segment: {None} | object

value of option “data_segment”

get_e(j=None, i=None, **kw)

Get max scheduling priority, ulimit -e

Call:
>>> e = opts.get_e(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
e: {None} | object

max scheduling priority, ulimit -e

get_f(j=None, i=None, **kw)

Get max size of files written by shell, ulimit -f

Call:
>>> f = opts.get_f(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
f: {None} | object

max size of files written by shell, ulimit -f

get_file_locks(j=None, i=None, **kw)

Get max number of file locks, ulimit -x

Call:
>>> file_locks = opts.get_file_locks(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
file_locks: {None} | object

value of option “file_locks”

get_file_size(j=None, i=None, **kw)

Get max size of files written by shell, ulimit -f

Call:
>>> file_size = opts.get_file_size(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
file_size: {None} | object

value of option “file_size”

get_i(j=None, i=None, **kw)

Get max number of pending signals, ulimit -i

Call:
>>> i = opts.get_i(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
i: {None} | object

max number of pending signals, ulimit -i

get_l(j=None, i=None, **kw)

Get max size that may be locked into memory, ulimit -l

Call:
>>> l = opts.get_l(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
l: {None} | object

max size that may be locked into memory, ulimit -l

get_locked_memory(j=None, i=None, **kw)

Get max size that may be locked into memory, ulimit -l

Call:
>>> locked_memory = opts.get_locked_memory(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
locked_memory: {None} | object

value of option “locked_memory”

get_m(j=None, i=None, **kw)

Get max resident set size, ulimit -m

Call:
>>> m = opts.get_m(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
m: {None} | object

max resident set size, ulimit -m

get_max_processes(j=None, i=None, **kw)

Get max number of procs avail to one user, ulimit -u

Call:
>>> max_processes = opts.get_max_processes(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
max_processes: {None} | object

value of option “max_processes”

get_message_queue_size(j=None, i=None, **kw)

Get max bytes in POSIX message queues, ulimit -q

Call:
>>> message_queue_size = opts.get_message_queue_size(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
message_queue_size: {None} | object

value of option “message_queue_size”

get_n(j=None, i=None, **kw)

Get max number of open files, ulimit -n

Call:
>>> n = opts.get_n(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
n: {None} | object

max number of open files, ulimit -n

get_open_files(j=None, i=None, **kw)

Get max number of open files, ulimit -n

Call:
>>> open_files = opts.get_open_files(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
open_files: {None} | object

value of option “open_files”

get_p(j=None, i=None, **kw)

Get pipe size in 512-byte blocks, ulimit -p

Call:
>>> p = opts.get_p(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
p: {None} | object

pipe size in 512-byte blocks, ulimit -p

get_pending_signals(j=None, i=None, **kw)

Get max number of pending signals, ulimit -i

Call:
>>> pending_signals = opts.get_pending_signals(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
pending_signals: {None} | object

value of option “pending_signals”

get_pipe_size(j=None, i=None, **kw)

Get pipe size in 512-byte blocks, ulimit -p

Call:
>>> pipe_size = opts.get_pipe_size(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
pipe_size: {None} | object

value of option “pipe_size”

get_processes(j=None, i=None, **kw)

Get max number of procs avail to one user, ulimit -u

Call:
>>> processes = opts.get_processes(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
processes: {None} | object

value of option “processes”

get_q(j=None, i=None, **kw)

Get max bytes in POSIX message queues, ulimit -q

Call:
>>> q = opts.get_q(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
q: {None} | object

max bytes in POSIX message queues, ulimit -q

get_r(j=None, i=None, **kw)

Get max real-time scheduling priority, ulimit -r

Call:
>>> r = opts.get_r(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
r: {None} | object

max real-time scheduling priority, ulimit -r

get_real_time_priority(j=None, i=None, **kw)

Get max real-time scheduling priority, ulimit -r

Call:
>>> real_time_priority = opts.get_real_time_priority(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
real_time_priority: {None} | object

value of option “real_time_priority”

get_s(j=None, i=None, **kw)

Get stack size limit, ulimit -s

Call:
>>> s = opts.get_s(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
s: {None} | object

stack size limit, ulimit -s

get_scheduling_priority(j=None, i=None, **kw)

Get max scheduling priority, ulimit -e

Call:
>>> scheduling_priority = opts.get_scheduling_priority(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
scheduling_priority: {None} | object

value of option “scheduling_priority”

get_set_size(j=None, i=None, **kw)

Get max resident set size, ulimit -m

Call:
>>> set_size = opts.get_set_size(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
set_size: {None} | object

value of option “set_size”

get_stack_size(j=None, i=None, **kw)

Get stack size limit, ulimit -s

Call:
>>> stack_size = opts.get_stack_size(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
stack_size: {None} | object

value of option “stack_size”

get_t(j=None, i=None, **kw)

Get max amount of cpu time in s, ulimit -t

Call:
>>> t = opts.get_t(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
t: {None} | object

max amount of cpu time in s, ulimit -t

get_time_limit(j=None, i=None, **kw)

Get max amount of cpu time in s, ulimit -t

Call:
>>> time_limit = opts.get_time_limit(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
time_limit: {None} | object

value of option “time_limit”

get_u(j=None, i=None, **kw)

Get max number of procs avail to one user, ulimit -u

Call:
>>> u = opts.get_u(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
u: {None} | object

max number of procs avail to one user, ulimit -u

get_ulimit(u, j=0, i=None)

Get a resource limit (ulimit) setting by name

Call:
>>> l = opts.get_ulimit(u, i=0)
Inputs:
opts: cape.cfdx.options.Options

Options interface

u: str

Name of the ulimit flag

j: None | {0} | int

Phase index

i: {None} | int

Case number

Outputs:
l: int

Value of the resource limit

Versions:

  • 2015-11-10 @ddalle: v1.0

  • 2022-10-30 @ddalle: v2.0; use optdict

get_user_processes(j=None, i=None, **kw)

Get max number of procs avail to one user, ulimit -u

Call:
>>> user_processes = opts.get_user_processes(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
user_processes: {None} | object

value of option “user_processes”

get_v(j=None, i=None, **kw)

Get max virtual memory avail to shell, ulimit -v

Call:
>>> v = opts.get_v(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
v: {None} | object

max virtual memory avail to shell, ulimit -v

get_virtual_memory(j=None, i=None, **kw)

Get max virtual memory avail to shell, ulimit -v

Call:
>>> virtual_memory = opts.get_virtual_memory(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
virtual_memory: {None} | object

value of option “virtual_memory”

get_x(j=None, i=None, **kw)

Get max number of file locks, ulimit -x

Call:
>>> x = opts.get_x(j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
x: {None} | object

max number of file locks, ulimit -x

set_c(v, j=None, mode=None)

Get core file size limit, ulimit -c

Call:
>>> opts.set_c(c, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

c: {None} | object

core file size limit, ulimit -c

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_core_file_size(v, j=None, mode=None)

Get core file size limit, ulimit -c

Call:
>>> opts.set_core_file_size(core_file_size, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

core_file_size: {None} | object

value of option “core_file_size”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_d(v, j=None, mode=None)

Get process data segment limit, ulimit -d

Call:
>>> opts.set_d(d, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

d: {None} | object

process data segment limit, ulimit -d

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_data_segment(v, j=None, mode=None)

Get process data segment limit, ulimit -d

Call:
>>> opts.set_data_segment(data_segment, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

data_segment: {None} | object

value of option “data_segment”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_e(v, j=None, mode=None)

Get max scheduling priority, ulimit -e

Call:
>>> opts.set_e(e, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

e: {None} | object

max scheduling priority, ulimit -e

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_f(v, j=None, mode=None)

Get max size of files written by shell, ulimit -f

Call:
>>> opts.set_f(f, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

f: {None} | object

max size of files written by shell, ulimit -f

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_file_locks(v, j=None, mode=None)

Get max number of file locks, ulimit -x

Call:
>>> opts.set_file_locks(file_locks, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

file_locks: {None} | object

value of option “file_locks”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_file_size(v, j=None, mode=None)

Get max size of files written by shell, ulimit -f

Call:
>>> opts.set_file_size(file_size, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

file_size: {None} | object

value of option “file_size”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_i(v, j=None, mode=None)

Get max number of pending signals, ulimit -i

Call:
>>> opts.set_i(i, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

i: {None} | object

max number of pending signals, ulimit -i

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_l(v, j=None, mode=None)

Get max size that may be locked into memory, ulimit -l

Call:
>>> opts.set_l(l, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

l: {None} | object

max size that may be locked into memory, ulimit -l

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_locked_memory(v, j=None, mode=None)

Get max size that may be locked into memory, ulimit -l

Call:
>>> opts.set_locked_memory(locked_memory, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

locked_memory: {None} | object

value of option “locked_memory”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_m(v, j=None, mode=None)

Get max resident set size, ulimit -m

Call:
>>> opts.set_m(m, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

m: {None} | object

max resident set size, ulimit -m

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_max_processes(v, j=None, mode=None)

Get max number of procs avail to one user, ulimit -u

Call:
>>> opts.set_max_processes(max_processes, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

max_processes: {None} | object

value of option “max_processes”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_message_queue_size(v, j=None, mode=None)

Get max bytes in POSIX message queues, ulimit -q

Call:
>>> opts.set_message_queue_size(message_queue_size, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

message_queue_size: {None} | object

value of option “message_queue_size”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_n(v, j=None, mode=None)

Get max number of open files, ulimit -n

Call:
>>> opts.set_n(n, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

n: {None} | object

max number of open files, ulimit -n

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_open_files(v, j=None, mode=None)

Get max number of open files, ulimit -n

Call:
>>> opts.set_open_files(open_files, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

open_files: {None} | object

value of option “open_files”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_p(v, j=None, mode=None)

Get pipe size in 512-byte blocks, ulimit -p

Call:
>>> opts.set_p(p, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

p: {None} | object

pipe size in 512-byte blocks, ulimit -p

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_pending_signals(v, j=None, mode=None)

Get max number of pending signals, ulimit -i

Call:
>>> opts.set_pending_signals(pending_signals, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

pending_signals: {None} | object

value of option “pending_signals”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_pipe_size(v, j=None, mode=None)

Get pipe size in 512-byte blocks, ulimit -p

Call:
>>> opts.set_pipe_size(pipe_size, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

pipe_size: {None} | object

value of option “pipe_size”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_processes(v, j=None, mode=None)

Get max number of procs avail to one user, ulimit -u

Call:
>>> opts.set_processes(processes, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

processes: {None} | object

value of option “processes”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_q(v, j=None, mode=None)

Get max bytes in POSIX message queues, ulimit -q

Call:
>>> opts.set_q(q, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

q: {None} | object

max bytes in POSIX message queues, ulimit -q

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_r(v, j=None, mode=None)

Get max real-time scheduling priority, ulimit -r

Call:
>>> opts.set_r(r, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

r: {None} | object

max real-time scheduling priority, ulimit -r

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_real_time_priority(v, j=None, mode=None)

Get max real-time scheduling priority, ulimit -r

Call:
>>> opts.set_real_time_priority(real_time_priority, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

real_time_priority: {None} | object

value of option “real_time_priority”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_s(v, j=None, mode=None)

Get stack size limit, ulimit -s

Call:
>>> opts.set_s(s, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

s: {None} | object

stack size limit, ulimit -s

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_scheduling_priority(v, j=None, mode=None)

Get max scheduling priority, ulimit -e

Call:
>>> opts.set_scheduling_priority(scheduling_priority, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

scheduling_priority: {None} | object

value of option “scheduling_priority”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_set_size(v, j=None, mode=None)

Get max resident set size, ulimit -m

Call:
>>> opts.set_set_size(set_size, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

set_size: {None} | object

value of option “set_size”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_stack_size(v, j=None, mode=None)

Get stack size limit, ulimit -s

Call:
>>> opts.set_stack_size(stack_size, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

stack_size: {None} | object

value of option “stack_size”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_t(v, j=None, mode=None)

Get max amount of cpu time in s, ulimit -t

Call:
>>> opts.set_t(t, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

t: {None} | object

max amount of cpu time in s, ulimit -t

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_time_limit(v, j=None, mode=None)

Get max amount of cpu time in s, ulimit -t

Call:
>>> opts.set_time_limit(time_limit, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

time_limit: {None} | object

value of option “time_limit”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_u(v, j=None, mode=None)

Get max number of procs avail to one user, ulimit -u

Call:
>>> opts.set_u(u, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

u: {None} | object

max number of procs avail to one user, ulimit -u

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_ulimit(u, l=None, j=None)

Set a resource limit (ulimit) by name and value

Call:
>>> opts.set_ulimit(u, l=None, i=None)
Inputs:
opts: cape.cfdx.options.Options

Options interface

u: str

Name of the ulimit flag

l: int

Value of the limit

j: {None} | int

Phase index

Versions:

  • 2015-11-10 @ddalle: v1.0

  • 2022-10-30 @ddalle: v2.0; use optdict

  • 2023-03-10 @ddalle: v2.1; remove i input

set_user_processes(v, j=None, mode=None)

Get max number of procs avail to one user, ulimit -u

Call:
>>> opts.set_user_processes(user_processes, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

user_processes: {None} | object

value of option “user_processes”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_v(v, j=None, mode=None)

Get max virtual memory avail to shell, ulimit -v

Call:
>>> opts.set_v(v, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

v: {None} | object

max virtual memory avail to shell, ulimit -v

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_virtual_memory(v, j=None, mode=None)

Get max virtual memory avail to shell, ulimit -v

Call:
>>> opts.set_virtual_memory(virtual_memory, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

virtual_memory: {None} | object

value of option “virtual_memory”

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_x(v, j=None, mode=None)

Get max number of file locks, ulimit -x

Call:
>>> opts.set_x(x, j=None, i=None, **kw)
Inputs:
opts: ULimitOpts

options interface

x: {None} | object

max number of file locks, ulimit -x

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar