calculate build times avg min max

Author: rf

.github/workflows/generate-stats.yml

@@ -97,7 +97,9 @@ jobs:
         run: pnpm install --frozen-lockfile
 
       - name: Run build benchmark
-        run: pnpm --filter @framework-tracker/stats-generator run:build ${{ matrix.framework.package }}
+        run: |
+          RUN_FREQUENCY=$(echo '${{ toJson(matrix.framework) }}' | jq -r '.measurements[] | select(.type == "build") | .runFrequency')
+          pnpm --filter @framework-tracker/stats-generator run:build ${{ matrix.framework.package }} $RUN_FREQUENCY
 
       - name: Upload build stats
         uses: actions/upload-artifact@v4

packages/docs/src/components/DependencyStats.astro

@@ -90,8 +90,8 @@ function formatBytesToMB(bytes: number): string {
               <th scope="col">Avg Install</th>
               <th scope="col">Min Install</th>
               <th scope="col">Max Install</th>
-              <th scope="col">Cold Build</th>
-              <th scope="col">Warm Build</th>
+              <th scope="col">Avg Cold Build</th>
+              <th scope="col">Avg Warm Build</th>
               <th scope="col">Build Output</th>
             </tr>
           </thead>
@@ -103,8 +103,8 @@ function formatBytesToMB(bytes: number): string {
                   <td>{(framework.avgInstallTimeMs / 1000).toFixed(2)}s</td>
                   <td>{(framework.minInstallTimeMs / 1000).toFixed(2)}s</td>
                   <td>{(framework.maxInstallTimeMs / 1000).toFixed(2)}s</td>
-                  <td>{(framework.coldBuildTimeMs / 1000).toFixed(2)}s</td>
-                  <td>{(framework.warmBuildTimeMs / 1000).toFixed(2)}s</td>
+                  <td>{(framework.coldBuildTime.avgMs / 1000).toFixed(2)}s</td>
+                  <td>{(framework.warmBuildTime.avgMs / 1000).toFixed(2)}s</td>
                   <td>{formatBytesToMB(framework.buildOutputSize)}</td>
                 </tr>
               ))

packages/docs/src/content/config.ts

@@ -11,8 +11,16 @@ const devtimeCollection = defineCollection({
     avgInstallTimeMs: z.number(),
     minInstallTimeMs: z.number(),
     maxInstallTimeMs: z.number(),
-    coldBuildTimeMs: z.number(),
-    warmBuildTimeMs: z.number(),
+    coldBuildTime: z.object({
+      avgMs: z.number(),
+      minMs: z.number(),
+      maxMs: z.number(),
+    }),
+    warmBuildTime: z.object({
+      avgMs: z.number(),
+      minMs: z.number(),
+      maxMs: z.number(),
+    }),
     buildOutputSize: z.number(),
     nodeModulesSize: z.number(),
     nodeModulesSizeProdOnly: z.number(),

packages/stats-generator/src/run-build-benchmark.ts

@@ -1,5 +1,6 @@
 import { execSync } from 'node:child_process'
 import { join } from 'node:path'
+import { existsSync, rmSync } from 'node:fs'
 import { packagesDir } from './constants.ts'
 import {
   getDirectorySize,
@@ -16,11 +17,22 @@ function measureBuildTime(cwd: string): number {
   return Math.round(end - start)
 }
 
+function rmBuildOutput(buildOutputPath: string): void {
+  if (existsSync(buildOutputPath)) {
+    console.info('Build output found. Removing build output')
+    rmSync(buildOutputPath, { recursive: true, force: true })
+  } else {
+    console.info('No build output found. Skipping removal of build output')
+  }
+}
+
 async function main() {
-  const { packageName } = parseArgs(
+  const { packageName, args } = parseArgs(
     'Usage: run-build-benchmark <package-name>\nExample: run-build-benchmark starter-astro',
   )
 
+  const runFrequency = parseInt(args[0] || '5', 10)
+
   const framework = await getFrameworkByPackage(packageName)
 
   if (!framework.buildOutputDir) {
@@ -34,21 +46,46 @@ async function main() {
 
   const packageDir = join(packagesDir, packageName)
 
-  console.info('Cold build...')
-  const coldBuildTimeMs = measureBuildTime(packageDir)
-  console.info(`  Cold build time: ${coldBuildTimeMs}ms`)
+  const coldBuildTimesMs: number[] = []
+  const warmBuildTimesMs: number[] = []
+
+  for (let i = 1; i <= runFrequency; i++) {
+    rmBuildOutput(framework.buildOutputDir)
 
-  console.info('\nWarm build...')
-  const warmBuildTimeMs = measureBuildTime(packageDir)
-  console.info(`  Warm build time: ${warmBuildTimeMs}ms`)
+    console.info('Cold build...')
+    const coldBuildTimeMs = measureBuildTime(packageDir)
+    coldBuildTimesMs.push(coldBuildTimeMs)
+    console.info(`  Cold build time: ${coldBuildTimeMs}ms`)
+
+    console.info('\nWarm build...')
+    const warmBuildTimeMs = measureBuildTime(packageDir)
+    warmBuildTimesMs.push(warmBuildTimeMs)
+    console.info(`  Warm build time: ${warmBuildTimeMs}ms`)
+  }
 
   const buildOutputPath = join(packageDir, framework.buildOutputDir)
   const buildOutputSize = getDirectorySize(buildOutputPath)
   console.info(`\nBuild output size: ${buildOutputSize} bytes`)
 
+  const coldBuildTime = {
+    avgMs:
+      coldBuildTimesMs.reduce((total, cur) => total + cur, 0) /
+      coldBuildTimesMs.length,
+    minMs: Math.min(...coldBuildTimesMs),
+    maxMs: Math.max(...coldBuildTimesMs),
+  }
+
+  const warmBuildTime = {
+    avgMs:
+      warmBuildTimesMs.reduce((total, cur) => total + cur, 0) /
+      warmBuildTimesMs.length,
+    minMs: Math.min(...warmBuildTimesMs),
+    maxMs: Math.max(...warmBuildTimesMs),
+  }
+
   const stats: BuildStats = {
-    coldBuildTimeMs,
-    warmBuildTimeMs,
+    coldBuildTime,
+    warmBuildTime,
     buildOutputSize,
   }
 

packages/stats-generator/src/types.ts

@@ -52,11 +52,17 @@ export interface InstallStats {
 }
 
 export interface BuildStats {
-  coldBuildTimeMs: number
-  warmBuildTimeMs: number
+  coldBuildTime: BuildTimeStat
+  warmBuildTime: BuildTimeStat
   buildOutputSize: number
 }
 
+export interface BuildTimeStat {
+  avgMs: number
+  minMs: number
+  maxMs: number
+}
+
 export interface FrameworkStats extends CIStats {
   name?: string
   package?: string