.TH SSHARE "1" "March 2012" "sshare 2.0" "SLURM Commands"

.SH "NAME"
sshare \- Tool for listing the shares of associations to a cluster.

.SH "SYNOPSIS"
\fBsshare\fR [\fIOPTIONS\fR...]

.SH "DESCRIPTION"
\fBsshare\fR is used to view SLURM share information.  This command is
only viable when running with the priority/multifactor plugin.
The sshare information is derived from a database with the interface
being provided by \fBslurmdbd\fR (SLURM Database daemon) which is
read in from the slurmctld and used to process the shares available
to a given association.  sshare provides SLURM share information of
Account, User, Raw Shares, Normalized Shares, Raw Usage, Normalized
Usage, Effective Usage, the Fair-share factor, the GrpCPUMins limit
and accumulated currently running CPU-minutes for each association.


.SH "OPTIONS"

.TP
\fB\-A\fR, \fB\-\-accounts=\fR
Display information for specific accounts (comma separated list).

.TP
\fB\-a\fR, \fB\-\-all\fR
Display information for all users.

.TP
\fB\-h\fR, \fB\-\-noheader\fR
No header will be added to the beginning of the output.

.TP
\fB\-l\fR, \fB\-\-long\fR
Long listing - includes the normalized usage information.

.TP
\fB\-M\fR, \fB\-\-clusters\fR=<\fIstring\fR>
Clusters to issue commands to.

.TP
\fB\-p\fR, \fB\-\-parsable\fR
Output will be '|' delimited with a '|' at the end.

.TP
\fB\-P\fR, \fB\-\-parsable2\fR
Output will be '|' delimited without a '|' at the end.

.TP
\fB\-u\fR, \fB\-\-users=\fR
Display information for specific users (comma separated list).

.TP
\fB\-v\fR, \fB\-\-verbose\fR
Display more information about the specified options.

.TP
\fB\-V\fR, \fB\-\-version\fR
Display the version number of sshare.

.TP
\fB\-\-help\fR
\fB\-\-usage\fR
Display a description of sshare options and commands.

.SH "SSHARE OUTPUT FIELDS"

.TP
\f3Account\fP
The Account.

.TP
\f3User\fP
The User.

.TP
\f3Raw Shares\fP
The raw shares assigned to the user or account.

.TP
\f3Norm Shares\fP
The shares assigned to the user or account normalized to the total
number of assigned shares.

.TP
\f3Raw Usage\fP
The number of cpu-seconds of all the jobs that charged the account by
the user.  This number will decay over time when PriorityDecayHalfLife
is defined.

.TP
\f3Norm Usage\fP (only appears with \fBsshare \-l\fR option)
The Raw Usage normalized to the total number of cpu-seconds of all
jobs run on the cluster, subject to the PriorityDecayHalfLife decay
when defined.

.TP
\f3Effectv Usage\fP
The Effective Usage augments the normalized usage to account for usage
from sibling accounts.

.TP
\f3FairShare\fP
The Fair-Share factor, based on a user or account's assigned shares and
the effective usage charged to them or their accounts.

.TP
\f3GrpCPUMins\fP
The CPU-minutes limit set on the account.

.TP
\f3CPURunMins\fP
The number of CPU-minutes accumulated by jobs currently running against
the account.

.SH "EXAMPLES"
.eo
.br
> sshare -A <Account>
.br
.br
> sshare --parsable --users=<User>
.br

.ec

.SH "COPYING"
Copyright (C) 2008 Lawrence Livermore National Security.
Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
CODE\-OCEC\-09\-009. All rights reserved.
.LP
This file is part of SLURM, a resource management program.
For details, see <http://slurm.schedmd.com/>.
.LP
SLURM is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your option)
any later version.
.LP
SLURM is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
details.

.SH "SEE ALSO"
\fBslurm.conf\fR(5),
\fBslurmdbd\fR(8)
