Merge pull request #1 from viniciusfabri/feature/add-benchmark

feat: Add benchmarking feature

Author: igorwulff

internal/input.go

@@ -9,22 +9,22 @@ import (
 )
 
 type Args struct {
-	day  string
-	part string
-	year string
+	Day  string
+	Part string
+	Year string
 	path string // plugin path
 }
 
 func ProcessArgs() Args {
 	year := flag.String("year", fmt.Sprint(time.Now().Year()), "Year of the challenge")
-	day := flag.String("day", "1", "Day of the challenge")
+	day := flag.String("day", "0", "Day of the challenge. 0 to run all days.")
 	part := flag.String("part", "1", "Part of the challenge")
 	flag.Parse()
 
 	args := Args{
-		day:  *day,
-		part: *part,
-		year: *year,
+		Day:  *day,
+		Part: *part,
+		Year: *year,
 	}
 
 	path, err := args.getPath()
@@ -39,7 +39,11 @@ func ProcessArgs() Args {
 }
 
 func (args Args) getPath() (string, error) {
-	path := filepath.Join("./", args.year, "day"+args.day, "part"+args.part)
+	if args.Day == "0" {
+		return "", nil
+	}
+
+	path := filepath.Join("./", args.Year, "day"+args.Day, "part"+args.Part)
 	if _, err := os.Stat(filepath.Dir(path)); os.IsNotExist(err) {
 		return "", fmt.Errorf("the directory %s does not exist", filepath.Dir(path))
 	}

internal/processor.go

@@ -6,6 +6,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"plugin"
+	"strings"
 )
 
 type PluginProcessor struct {
@@ -32,7 +33,7 @@ func (p PluginProcessor) CallFunc(input *[]byte) (string, error) {
 	}
 
 	// Look up the Process function
-	symProcess, err := plug.Lookup("Part" + p.Args.part)
+	symProcess, err := plug.Lookup("Part" + p.Args.Part)
 	if err != nil {
 		return "", fmt.Errorf("error looking up process: %v", err)
 	}
@@ -47,22 +48,24 @@ func (p PluginProcessor) CallFunc(input *[]byte) (string, error) {
 	return processFunc(string(*input)), nil
 }
 
-func (p PluginProcessor) RunTests() {
-	cmd := exec.Command("go", "test", fmt.Sprintf("./%s/day%s/", p.Args.year, p.Args.day))
+func (p PluginProcessor) RunTests() error {
+	cmd := exec.Command("go", "test", fmt.Sprintf("./%s/day%s/", p.Args.Year, p.Args.Day))
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
 
 	fmt.Printf("\nRunning tests: %s\n", cmd.String())
 
 	if err := cmd.Run(); err != nil {
 		fmt.Println("Tests failed.")
-		return
+		return err
 	}
+
+	return nil
 }
 
 func (p PluginProcessor) GetInput() (*[]byte, error) {
 	// Determine the input file path
-	path := filepath.Join("./", p.Args.year, "day"+p.Args.day, "input.txt")
+	path := filepath.Join("./", p.Args.Year, "day"+p.Args.Day, "input.txt")
 
 	// Read the input file
 	data, err := os.ReadFile(path)
@@ -76,3 +79,59 @@ func (p PluginProcessor) GetInput() (*[]byte, error) {
 
 	return &data, nil
 }
+
+func GetAllPluginProcessors(args Args) ([]PluginProcessor, error) {
+	var baseDir = filepath.Join("./", args.Year)
+	var processors []PluginProcessor
+
+	err := filepath.Walk(baseDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if info.IsDir() {
+			return nil
+		}
+
+		parts := strings.Split(path, string(os.PathSeparator))
+		if len(parts) != 3 {
+			return nil
+		}
+
+		if !strings.HasPrefix(parts[1], "day") {
+			return nil
+		}
+
+		if !strings.HasPrefix(parts[2], "part") || strings.Contains(parts[2], "test") || !strings.HasSuffix(parts[2], ".go") {
+			return nil
+		}
+
+		year := parts[0]
+		day := parts[1][3:]
+		part := parts[2][4 : len(parts[2])-3]
+
+		args := Args{
+			Year: year,
+			Day:  day,
+			Part: part,
+		}
+		args.path, err = args.getPath()
+		if err != nil {
+			return err
+		}
+
+		processors = append(processors, PluginProcessor{
+			Args: args,
+		})
+
+		return nil
+	})
+
+	if err != nil {
+		fmt.Println("Error scanning directories:", err)
+
+		return nil, err
+	}
+
+	return processors, nil
+}

runner.go

@@ -2,32 +2,77 @@ package aoc
 
 import (
 	"fmt"
+	"os"
+	"text/tabwriter"
+	"time"
 
 	internal "github.com/igorwulff/aoc/internal"
 )
 
-func Run() {
-	args := internal.ProcessArgs()
+type BenchmarkResult struct {
+	TotalTimeInMs int64
+}
 
-	plugin := internal.PluginProcessor{Args: args}
-	if err := plugin.Build(); err != nil {
-		fmt.Println(err)
-		return
+func Run() ([]BenchmarkResult, error) {
+	args := internal.ProcessArgs()
+	var plugins []internal.PluginProcessor
+	// Benchmarking mode
+	if args.Day == "0" {
+		allPlugins, err := internal.GetAllPluginProcessors(args)
+		if err != nil {
+			fmt.Println(err)
+			return nil, err
+		}
+		plugins = append(plugins, allPlugins...)
+	} else {
+		plugins = append(plugins, internal.PluginProcessor{Args: args})
 	}
 
-	input, err := plugin.GetInput()
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
+	results := make([]BenchmarkResult, len(plugins))
+	for i, plugin := range plugins {
+		input, err := plugin.GetInput()
+		if err != nil {
+			fmt.Printf("Could not find input.txt for Day %s Part %s\n", plugin.Args.Day, plugin.Args.Part)
+			return nil, err
+		}
 
-	plugin.RunTests()
+		fmt.Printf("Building day %s part %s... ", plugin.Args.Day, plugin.Args.Part)
+		if err := plugin.Build(); err != nil {
+			fmt.Print("ERROR!\n")
+			fmt.Println(err)
+			return nil, err
+		}
+		fmt.Print("OK!\n")
+
+		fmt.Print("Executing tests... ")
+		if err := plugin.RunTests(); err != nil {
+			fmt.Print("ERROR!\n")
+			fmt.Println(err)
+			return nil, err
+		}
+
+		fmt.Print("Executing main function... ")
+		timeBeforeExec := time.Now().UnixMilli()
+		output, err := plugin.CallFunc(input)
+		if err != nil {
+			fmt.Print("ERROR!\n")
+			fmt.Println(err)
+			return nil, err
+		}
+		timeAfterExec := time.Now().UnixMilli()
+		results[i] = BenchmarkResult{TotalTimeInMs: timeAfterExec - timeBeforeExec}
+
+		fmt.Printf("Solution: %s\n", output)
+	}
 
-	output, err := plugin.CallFunc(input)
-	if err != nil {
-		fmt.Println(err)
-		return
+	fmt.Println("Execution finished! Total time:")
+	w := tabwriter.NewWriter(os.Stdout, 0, 4, 4, ' ', 0)
+	fmt.Fprintln(w, "Day\tPart\tTime (ms)")
+	for i, plugin := range plugins {
+		// @TODO: would be nice to join day & parts in a single row, but for now it's already nice they're alphabetically sorted
+		fmt.Fprintf(w, "%s\t%s\t%d\n", plugin.Args.Day, plugin.Args.Part, results[i].TotalTimeInMs)
 	}
+	w.Flush()
 
-	fmt.Println("\nSolution:\n", output)
+	return results, nil
 }