cc-backend/graph/schema.graphqls

scalar Time
scalar NullableFloat
scalar MetricScope
scalar JobState

type Job {
  id:               ID!
  jobId:            Int!
  user:             String!
  project:          String!
  cluster:          String!
  startTime:        Time!
  duration:         Int!
  numNodes:         Int!
  numHWThreads:     Int!
  numAcc:           Int!
  SMT:              Int!
  exclusive:        Int!
  partition:        String!
  arrayJobId:       Int!
  monitoringStatus: Int!
  state:            JobState!
  tags:             [Tag!]!
  resources:        [JobResource!]!
}

type Cluster {
  name:         String!
  metricConfig: [MetricConfig!]!
  filterRanges: FilterRanges!
  partitions:   [Partition!]!
}

type Partition {
  name:            String!
  processorType:   String!
  socketsPerNode:  Int!
  coresPerSocket:  Int!
  threadsPerCore:  Int!
  flopRateScalar:  Int!
  flopRateSimd:    Int!
  memoryBandwidth: Int!
  topology:        Topology!
}

type Topology {
  node:         [Int!]
  socket:       [[Int!]!]
  memoryDomain: [[Int!]!]
  die:          [[Int!]!]
  core:         [[Int!]!]
  accelerators: [Accelerator!]
}

type Accelerator {
  id:    String!
  type:  String!
  model: String!
}

type MetricConfig {
  name:     String!
  unit:     String!
  scope:    String!
  timestep: Int!
  Peak:     Float!
  Normal:   Float!
  Caution:  Float!
  Alert:    Float!
}

type Tag {
  id:   ID!
  type: String!
  name: String!
}

type JobResource {
  hostname:      String!
  hwthreads:     [Int!]
  accelerators:  [Int!]
  configuration: String
}

type JobMetricWithName {
  name: String!

  node:         JobMetric
  socket:       JobMetric
  memoryDomain: JobMetric
  core:         JobMetric
  hwthread:     JobMetric
}

type JobMetric {
  unit:             String!
  scope:            MetricScope!
  timestep:         Int!
  series:           [Series!]!
  statisticsSeries: [StatsSeries!]
}

type Series {
  hostname:   String!
  id:         Int
  statistics: MetricStatistics
  data:       [NullableFloat!]!
}

type MetricStatistics {
  avg: Float!
  min: Float!
  max: Float!
}

type StatsSeries {
  mean: [NullableFloat!]
  min:  [NullableFloat!]
  max:  [NullableFloat!]
}

type MetricFootprints {
  name: String!
  footprints: [NullableFloat!]!
}

enum Aggregate { USER, PROJECT, CLUSTER }

type NodeMetric {
  name: String!
  data: [NullableFloat!]!
}

type NodeMetrics {
  id:      String!
  metrics: [NodeMetric!]!
}

type Query {
  clusters:     [Cluster!]!   # List of all clusters
  tags:         [Tag!]!    # List of all tags

  job(id: ID!): Job
  jobMetrics(id: ID!, metrics: [String!]): [JobMetricWithName!]!
  jobsFootprints(filter: [JobFilter!], metrics: [String!]!): [MetricFootprints]!

  jobs(filter: [JobFilter!], page: PageRequest, order: OrderByInput): JobResultList!
  jobsStatistics(filter: [JobFilter!], groupBy: Aggregate): [JobsStatistics!]!

  rooflineHeatmap(filter: [JobFilter!]!, rows: Int!, cols: Int!, minX: Float!, minY: Float!, maxX: Float!, maxY: Float!): [[Float!]!]!

  nodeMetrics(cluster: ID!, nodes: [String!], metrics: [String!], from: Time!, to: Time!): [NodeMetrics!]!
}

type Mutation {
  createTag(type: String!, name: String!): Tag!
  deleteTag(id: ID!): ID!
  addTagsToJob(job: ID!, tagIds: [ID!]!): [Tag!]!
  removeTagsFromJob(job: ID!, tagIds: [ID!]!): [Tag!]!

  updateConfiguration(name: String!, value: String!): String
}

type IntRangeOutput { from: Int!, to: Int! }
type TimeRangeOutput { from: Time!, to: Time! }

type FilterRanges {
  duration:  IntRangeOutput!
  numNodes:  IntRangeOutput!
  startTime: TimeRangeOutput!
}

input JobFilter {
  tags:        [ID!]
  jobId:       StringInput
  user:        StringInput
  project:     StringInput
  cluster:     StringInput
  duration:    IntRange
  numNodes:    IntRange
  startTime:   TimeRange
  state:       [JobState!]
  flopsAnyAvg: FloatRange
  memBwAvg:    FloatRange
  loadAvg:     FloatRange
  memUsedMax:  FloatRange
}

input OrderByInput {
  field: String!
  order: SortDirectionEnum! = ASC
}

enum SortDirectionEnum {
  DESC
  ASC
}

input StringInput {
  eq:         String
  contains:   String
  startsWith: String
  endsWith:   String
}

input IntRange   { from: Int!,   to: Int! }
input FloatRange { from: Float!, to: Float! }
input TimeRange  { from: Time,   to: Time }

type JobResultList {
  items:  [Job!]!
  offset: Int
  limit:  Int
  count:  Int
}

type HistoPoint {
  count: Int!
  value: Int!
}

type JobsStatistics  {
  id:             ID!            # If `groupBy` was used, ID of the user/project/cluster
  totalJobs:      Int!           # Number of jobs that matched
  shortJobs:      Int!           # Number of jobs with a duration of less than 2 minutes
  totalWalltime:  Int!           # Sum of the duration of all matched jobs in hours
  totalCoreHours: Int!           # Sum of the core hours of all matched jobs
  histWalltime:   [HistoPoint!]! # value: hour, count: number of jobs with a rounded duration of value
  histNumNodes:   [HistoPoint!]! # value: number of nodes, count: number of jobs with that number of nodes
}

input PageRequest {
  itemsPerPage: Int!
  page:         Int!
}