# doc-cache created by Octave 6.4.0
# name: cache
# type: cell
# rows: 3
# columns: 4
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
parallel_doc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 415
 -- Function File: parallel_doc ()
 -- Function File: parallel_doc (KEYWORD)
     Show parallel package documentation.

     Runs the info viewer Octave is configured with on the documentation
     in info format of the installed parallel package.  Without
     argument, the top node of the documentation is displayed.  With an
     argument, the respective index entry is searched for and its node
     displayed.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Show parallel package documentation.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
pararrayfun


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1155
 -- Function File: [O1, O2, ...] = pararrayfun (NPROC, FUN, A1, A2, ...)
 -- Function File: pararrayfun (nproc, fun, ..., "UniformOutput", VAL)
 -- Function File: pararrayfun (nproc, fun, ..., "ErrorHandler",
          ERRFUNC)
     Evaluates a function for corresponding elements of an array.
     Argument and options handling is analogical to 'parcellfun', except
     that arguments are arrays rather than cells.  If cells occur as
     arguments, they are treated as arrays of singleton cells.  Arrayfun
     supports one extra option compared to parcellfun: "Vectorized".
     This option must be given together with "ChunksPerProc" and it
     indicates that FUN is able to operate on vectors rather than just
     scalars, and returns a vector.  The same must be true for ERRFUNC,
     if given.  In this case, the array is split into chunks which are
     then directly served to FUNC for evaluation, and the results are
     concatenated to output arrays.  If "CumFunc" is also specified (see
     'parcellfun'), FUN is expected to return the result of the same
     cumulative operation instead of vectors.

     See also: parcellfun, arrayfun.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Evaluates a function for corresponding elements of an array.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
parcellfun


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2694
 -- Function File: [O1, O2, ...] = parcellfun (NPROC, FUN, A1, A2, ...)
 -- Function File: parcellfun (nproc, fun, ..., "UniformOutput", VAL)
 -- Function File: parcellfun (nproc, fun, ..., "ErrorHandler", ERRFUNC)
 -- Function File: parcellfun (nproc, fun, ..., "VerboseLevel", VAL)
 -- Function File: parcellfun (nproc, fun, ..., "ChunksPerProc", VAL)
 -- Function File: parcellfun (nproc, fun, ..., "CumFunc", CUMFUNC)
     Evaluates a function for multiple argument sets using multiple
     processes in parallel.

     NPROC specifies the number of processes and must be at least 1.  It
     will be cut to the number of available CPU cores or the size of the
     input argument(s), whichever is lower.  FUN is a function handle
     pointing to the requested evaluating function.  A1, A2 etc.  should
     be cell arrays of equal size.  O1, O2 etc.  will be set to
     corresponding output arguments.

     The UniformOutput and ErrorHandler options are supported with
     meaning identical to "cellfun".  If option VerboseLevel is set to 1
     (default is 0), progress messages are printed to stderr.  The
     ChunksPerProc option controls the number of chunks which contains
     elementary jobs.  This option is particularly useful when time
     execution of function is small.  Setting this option to 100 is a
     good choice in most cases.

     Instead of returning a result for each argument, parcellfun returns
     only one cumulative result if "CumFunc" is non-empty.  CUMFUNC must
     be a function which performs an operation on two sets of outputs of
     FUN and returnes as many outputs as FUN.  If NOUT is the number of
     outputs of FUN, CUMFUNC gets a previous output set of FUN or of
     CUMFUNC as first NOUT arguments and the current output of FUN as
     last NOUT arguments.  The performed operation must be
     mathematically commutative and associative.  If the operation is
     e.g.  addition, the result will be the sum(s) of the outputs of FUN
     over all calls of FUN.  Since floating point addition and
     multiplication are only approximately associative, the cumulative
     result will not be exactly reproducible.

     Each process has its own pseudo random number generator, so when
     using this function for example to perform Monte-Carlo simulations
     one generally cannot expect results to be exactly reproducible.
     Exact reproducibility may be achievable by generating the random
     number sequence before calling parcellfun and providing the random
     numbers as arguments to FUN.

     See 'parallel_doc ("limitations")' for possible limitations on how
     FUN can be defined.

     See also: parcellfun_set_nproc.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Evaluates a function for multiple argument sets using multiple processes
in p...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
pserver


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4311
 -- Function File: pserver ()
 -- Function File: pserver (OPTIONS)
 -- Function File: pserver ("kill")
     Starts or stops a server of the parallel cluster.

     OPTIONS: structure of options; field 'use_tls' is 'true' by default
     (TLS with SRP authentication); if set to 'false', there will be no
     encryption or authentication.  Field 'auth_file' can be set to an
     alternative path to the file with authentication information (see
     below).  Fields 'cmd_port' (default: 12502) and 'data_port'
     (default: 12501) can be set to change the ports of the command
     channel and the data channel, respectively.

     If called as 'pserver ("kill")', the server will be stopped by
     sending it a signal, taking its process id from its pid-file
     '/tmp/.octave-<hostname>.pid'.  Otherwise the server will be
     started.

     The servers exectuable file ('octave-pserver') is searched for by
     first assuming the directory structure of a regular package
     installation, then by searching Octaves function search path for
     it, and then by the called shell in its shell search path.

     If a directory path corresponding to the current directory of the
     client exists on the server machine, it will be used as the servers
     current directory for the respective client (multiple clients are
     possible).  Otherwise, '/tmp' will be used.  The Octave functions
     the server is supposed to call and the files it possibly has to
     access must be available at the server machine.  This can e.g.  be
     achieved by having the server machine mount a network file system
     (which is outside the scope of this package documentation).

     If a directory path corresponding to the current directory of the
     client exists on the server machine, it will be used as the servers
     current directory for the respective client (multiple clients are
     possible).  Otherwise, '/tmp' will be used.  The Octave functions
     the server is supposed to call and the files it possibly has to
     access must be available at the server machine.  This can e.g.  be
     achieved by having the server machine mount a network file system
     (which is outside the scope of this package documentation).

     If a connection is accepted from a client, the server collects a
     network identifier and the names of all server machines of the
     network from the client.  Then, connections are automatically
     established between all machines of the network.  Data exchange
     will be possible between all machines (client or server) in both
     directions.  Commands can only be sent from the client to any
     server.

     The opaque variable holding the network connections, in the same
     order as in the corresponding variable returned by 'pconnect', is
     accessible under the variable name 'sockets' at the server side.
     Do not overwrite or clear this variable.  The own server machine
     will also be contained at some index position of this variable, but
     will not correspond to a real connection.  See 'pconnect' for
     further information.

     The client and the server must both use or both not use TLS. If TLS
     is switched off, different measures must be taken to protect ports
     of the command and data channels at the servers and the client
     against unauthorized access, e.g.  by a firewall or by physical
     isolation of the network.

     For using TLS, authorization data must be present at the server
     machine.  These data can conveniently be generated by
     'parallel_generate_srp_data'; the helptext of the latter function
     documents the expected location of these data.

     The SRP password will be sent over the encrypted TLS channel from
     the client to each server, to avoid permanently storing passwords
     at the server for server-to-server data connections.  Due to
     inevitable usage of external libraries, memory with sensitive data
     can, however, be on the swap device even after shutdown of the
     application.

     The server executable file 'octave-pserver' is installed and runs
     at GNU/Linux, but not at some other operating systems like Windows
     and macOS.

     See also: pconnect, reval, psend, precv, sclose,
     parallel_generate_srp_data, select_sockets.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Starts or stops a server of the parallel cluster.





