CPU and Max RSS Analysis tools

changes.d/2100.feat.md

@@ -0,0 +1 @@
+Adding CPU time and Max RSS to Analysis Tools

src/components/cylc/analysis/AnalysisTable.vue

@@ -56,7 +56,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 <script>
 import { upperFirst } from 'lodash'
-import { formatDuration } from '@/utils/tasks'
+import {
+  formatDuration,
+  formatHeader,
+  formatChartLabels,
+} from '@/utils/tasks'
 import {
   initialOptions,
   updateInitialOptionsEvent,
@@ -128,50 +132,76 @@ export default {
   computed: {
     shownHeaders () {
       const times = upperFirst(this.timingOption)
-      const timingHeaders = [
-        {
-          title: `Mean T-${times}`,
-          key: `mean${times}Time`,
-          formatter: formatDuration,
-          allowZeros: false
-        },
-        {
-          title: `Std Dev T-${times}`,
-          key: `stdDev${times}Time`,
-          formatter: formatDuration,
-          allowZeros: true
-        },
-        {
-          title: `Min T-${times}`,
-          key: `min${times}Time`,
-          formatter: formatDuration,
-          allowZeros: false
-        },
-        {
-          title: `Q1 T-${times}`,
-          key: `${times.toLowerCase()}Quartiles.0`,
-          formatter: formatDuration,
-          allowZeros: false
-        },
-        {
-          title: `Median T-${times}`,
-          key: `${times.toLowerCase()}Quartiles.1`,
-          formatter: formatDuration,
-          allowZeros: false
-        },
-        {
-          title: `Q3 T-${times}`,
-          key: `${times.toLowerCase()}Quartiles.2`,
-          formatter: formatDuration,
-          allowZeros: false
-        },
-        {
-          title: `Max T-${times}`,
-          key: `max${times}Time`,
+      const timingHeaders = []
+      // Check if there are any stats to show
+      const stats = this.tasks.some((task) => task.count > 1)
+      if (stats) {
+        timingHeaders.push(
+          {
+            title: `Mean ${formatChartLabels(times)}`,
+            key: `${formatHeader('mean', times)}`,
+            formatter: formatDuration,
+            allowZeros: true,
+            timingOption: this.timingOption
+          },
+          {
+            title: `Min ${formatChartLabels(times)}`,
+            key: `${formatHeader('min', times)}`,
+            formatter: formatDuration,
+            allowZeros: true,
+            timingOption: this.timingOption
+          },
+          {
+            title: `Q1 ${formatChartLabels(times)}`,
+            key: `${formatHeader('quartiles', times)}Quartiles.0`,
+            formatter: formatDuration,
+            allowZeros: true,
+            timingOption: this.timingOption
+          },
+          {
+            title: `Median ${formatChartLabels(times)}`,
+            key: `${formatHeader('quartiles', times)}Quartiles.1`,
+            formatter: formatDuration,
+            allowZeros: true,
+            timingOption: this.timingOption
+          },
+          {
+            title: `Q3 ${formatChartLabels(times)}`,
+            key: `${formatHeader('quartiles', times)}Quartiles.2`,
+            formatter: formatDuration,
+            allowZeros: true,
+            timingOption: this.timingOption
+          },
+          {
+            title: `Max ${formatChartLabels(times)}`,
+            key: `${formatHeader('max', times)}`,
+            formatter: formatDuration,
+            allowZeros: true,
+            timingOption: this.timingOption
+          }
+        )
+      } else {
+        timingHeaders.push(
+          {
+            title: `${formatChartLabels(times)}`,
+            key: `${formatHeader('mean', times)}`,
+            formatter: formatDuration,
+            allowZeros: true,
+            timingOption: this.timingOption
+          }
+        )
+      }
+
+      // Don't show std dev for cpuTime or maxRss
+      if (this.timingOption !== 'cpuTime' && this.timingOption !== 'maxRss' && stats) {
+        timingHeaders.push({
+          title: `Std Dev ${times}`,
+          key: `${formatHeader('stdDev', times)}`,
           formatter: formatDuration,
-          allowZeros: false
-        }
-      ]
+          allowZeros: true,
+          timingOption: this.timingOption
+        })
+      }
       return this.headers.concat(timingHeaders)
     }
   },
@@ -186,7 +216,7 @@ export default {
         value = value[index]
       }
       if (header.formatter) {
-        return header.formatter(value, header.allowZeros)
+        return header.formatter(value, header.allowZeros, this.timingOption)
       }
       return value
     }

src/components/cylc/analysis/BoxPlot.vue

@@ -65,7 +65,11 @@ import {
   mdiSortVariant,
 } from '@mdi/js'
 import { upperFirst } from 'lodash'
-import { formatDuration } from '@/utils/tasks'
+import {
+  formatDuration,
+  getTimingOption,
+  formatChartLabels
+} from '@/utils/tasks'
 import { useReducedAnimation } from '@/composables/localStorage'
 import {
   initialOptions,
@@ -165,12 +169,25 @@ export default {
       },
       tooltip: {
         custom ({ seriesIndex, dataPointIndex, w }) {
-          const max = formatDuration(w.globals.seriesCandleC[seriesIndex][dataPointIndex], true)
-          const q3 = formatDuration(w.globals.seriesCandleL[seriesIndex][dataPointIndex], true)
-          const med = formatDuration(w.globals.seriesCandleM[seriesIndex][dataPointIndex], true)
-          const q1 = formatDuration(w.globals.seriesCandleH[seriesIndex][dataPointIndex], true)
-          const min = formatDuration(w.globals.seriesCandleO[seriesIndex][dataPointIndex], true)
-          return `
+          const max = formatDuration(w.globals.seriesCandleC[0][dataPointIndex], true, props.timingOption)
+          const q3 = formatDuration(w.globals.seriesCandleL[0][dataPointIndex], true, props.timingOption)
+          const med = formatDuration(w.globals.seriesCandleM[0][dataPointIndex], true, props.timingOption)
+          const q1 = formatDuration(w.globals.seriesCandleH[0][dataPointIndex], true, props.timingOption)
+          const min = formatDuration(w.globals.seriesCandleO[0][dataPointIndex], true, props.timingOption)
+          if (props.timingOption === 'maxRss') {
+            const memAlloc = formatDuration(w.globals.series[0][dataPointIndex], true, props.timingOption)
+            return `
+            <div class="pa-2">
+              <div>Maximum: ${max}</div>
+              <div>Q3: ${q3} </div>
+              <div>Median: ${med}</div>
+              <div>Q1: ${q1}</div>
+              <div>Minimum: ${min}</div>
+              <div>Memory Allocated: ${memAlloc}</div>
+            </div>
+          `
+          } else {
+            return `
             <div class="pa-2">
               <div>Maximum: ${max}</div>
               <div>Q3: ${q3} </div>
@@ -179,6 +196,7 @@ export default {
               <div>Minimum: ${min}</div>
             </div>
           `
+          }
         },
       },
       plotOptions: {
@@ -194,10 +212,10 @@ export default {
       },
       xaxis: {
         title: {
-          text: `${upperFirst(props.timingOption)} time`,
+          text: `${formatChartLabels(props.timingOption)}`,
         },
         labels: {
-          formatter: (value) => formatDuration(value, true)
+          formatter: (value) => formatDuration(value, true, props.timingOption)
         },
       },
     }))
@@ -221,12 +239,13 @@ export default {
         data.push({
           x: sortedTasks[i].name,
           y: [
-            sortedTasks[i][`min${upperFirst(this.timingOption)}Time`],
+            sortedTasks[i][`min${upperFirst(getTimingOption(this.timingOption))}`],
             sortedTasks[i][`${this.timingOption}Quartiles`][0],
             sortedTasks[i][`${this.timingOption}Quartiles`][1],
             sortedTasks[i][`${this.timingOption}Quartiles`][2],
-            sortedTasks[i][`max${upperFirst(this.timingOption)}Time`],
-          ],
+            sortedTasks[i][`max${upperFirst(getTimingOption(this.timingOption))}`],
+            sortedTasks[i].memAlloc
+          ]
         })
       }
       return [{ data }]
@@ -241,10 +260,10 @@ export default {
         { title: 'Task name', value: 'name' },
         { title: 'Platform', value: 'platform' },
         { title: 'Count', value: 'count' },
-        { title: `Mean ${this.timingOption} time`, value: `mean${upperFirst(this.timingOption)}Time` },
-        { title: `Median ${this.timingOption} time`, value: `median${upperFirst(this.timingOption)}Time` },
-        { title: `Min ${this.timingOption} time`, value: `min${upperFirst(this.timingOption)}Time` },
-        { title: `Max ${this.timingOption} time`, value: `max${upperFirst(this.timingOption)}Time` },
+        { title: `Mean ${formatChartLabels(this.timingOption)}`, value: `mean${upperFirst(getTimingOption(this.timingOption))}` },
+        { title: `Median ${formatChartLabels(this.timingOption)}`, value: `median${upperFirst(getTimingOption(this.timingOption))}` },
+        { title: `Min ${formatChartLabels(this.timingOption)}`, value: `min${upperFirst(getTimingOption(this.timingOption))}` },
+        { title: `Max ${formatChartLabels(this.timingOption)}`, value: `max${upperFirst(getTimingOption(this.timingOption))}` },
       ]
     },
   },

src/components/cylc/analysis/TimeSeries.vue

@@ -93,11 +93,14 @@ import {
   difference,
   pick,
   union,
-  uniq,
-  upperFirst
+  uniq
 } from 'lodash'
 import gql from 'graphql-tag'
-import { formatDuration } from '@/utils/tasks'
+import {
+  getTimingOption,
+  formatDuration,
+  formatChartLabels
+} from '@/utils/tasks'
 import {
   mdiDownload,
   mdiRefresh,
@@ -119,7 +122,9 @@ const jobFields = [
   'totalTime',
   'queueTime',
   'runTime',
-  'startedTime'
+  'startedTime',
+  'maxRss',
+  'cpuTime'
 ]
 
 /** The one-off query which retrieves historical job timing statistics */
@@ -284,7 +289,7 @@ export default {
             const currentStartedTime = seriesData[job.name].data[job.cyclePoint].startedTime
             // Only add data if this job was run more recently than any existing data
             if (currentStartedTime === undefined || job.startedTime.localeCompare(currentStartedTime) === 1) {
-              time = job[`${this.timingOption}Time`]
+              time = job[getTimingOption(this.timingOption)]
               Object.assign(seriesData[job.name].data[job.cyclePoint], {
                 x: job.cyclePoint,
                 y: time,
@@ -366,7 +371,7 @@ export default {
               if (!value) {
                 return null
               }
-              const y = formatDuration(value, true)
+              const y = formatDuration(value, true, this.timingOption)
               const platform = this.series[seriesIndex].data[dataPointIndex].platform
               return `${y} (${platform})`
             }
@@ -384,12 +389,10 @@ export default {
           forceNiceScale: true,
           min: this.showOrigin ? 0 : undefined,
           title: {
-            text: upperFirst(this.timingOption) + ' time',
+            text: formatChartLabels(this.timingOption),
           },
           labels: {
-            formatter: function (value) {
-              return formatDuration(value, true)
-            }
+            formatter: (value) => formatDuration(value, true, this.timingOption)
           },
         },
       }
@@ -445,12 +448,10 @@ export default {
         yaxis: {
           tickAmount: 3,
           title: {
-            text: upperFirst(this.timingOption) + ' time',
+            text: formatChartLabels(this.timingOption),
           },
           labels: {
-            formatter: function (value) {
-              return formatDuration(value, true)
-            }
+            formatter: (value) => formatDuration(value, true, this.timingOption)
           },
           min: this.showOrigin ? 0 : undefined
         },