Reformat and Refactor packages. Rebuild GraphQL.

internal/graph/model/models.go

@@ -3,124 +3,3 @@
 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file.
 package model
-
-import (
-	"encoding/json"
-	"strconv"
-)
-
-type Cluster struct {
-	Name         string          `json:"name"`
-	MetricConfig []*MetricConfig `json:"metricConfig"`
-	FilterRanges *FilterRanges   `json:"filterRanges"`
-	SubClusters  []*SubCluster   `json:"subClusters"`
-
-	// NOT part of the GraphQL API. This has to be a JSON object with a field `"kind"`.
-	// All other fields depend on that kind (e.g. "cc-metric-store", "influxdb-v2").
-	MetricDataRepository json.RawMessage `json:"metricDataRepository"`
-}
-
-// Return a list of socket IDs given a list of hwthread IDs.
-// Even if just one hwthread is in that socket, add it to the list.
-// If no hwthreads other than those in the argument list are assigned to
-// one of the sockets in the first return value, return true as the second value.
-// TODO: Optimize this, there must be a more efficient way/algorithm.
-func (topo *Topology) GetSocketsFromHWThreads(hwthreads []int) (sockets []int, exclusive bool) {
-	socketsMap := map[int]int{}
-	for _, hwthread := range hwthreads {
-		for socket, hwthreadsInSocket := range topo.Socket {
-			for _, hwthreadInSocket := range hwthreadsInSocket {
-				if hwthread == hwthreadInSocket {
-					socketsMap[socket] += 1
-				}
-			}
-		}
-	}
-
-	exclusive = true
-	hwthreadsPerSocket := len(topo.Node) / len(topo.Socket)
-	sockets = make([]int, 0, len(socketsMap))
-	for socket, count := range socketsMap {
-		sockets = append(sockets, socket)
-		exclusive = exclusive && count == hwthreadsPerSocket
-	}
-
-	return sockets, exclusive
-}
-
-// Return a list of core IDs given a list of hwthread IDs.
-// Even if just one hwthread is in that core, add it to the list.
-// If no hwthreads other than those in the argument list are assigned to
-// one of the cores in the first return value, return true as the second value.
-// TODO: Optimize this, there must be a more efficient way/algorithm.
-func (topo *Topology) GetCoresFromHWThreads(hwthreads []int) (cores []int, exclusive bool) {
-	coresMap := map[int]int{}
-	for _, hwthread := range hwthreads {
-		for core, hwthreadsInCore := range topo.Core {
-			for _, hwthreadInCore := range hwthreadsInCore {
-				if hwthread == hwthreadInCore {
-					coresMap[core] += 1
-				}
-			}
-		}
-	}
-
-	exclusive = true
-	hwthreadsPerCore := len(topo.Node) / len(topo.Core)
-	cores = make([]int, 0, len(coresMap))
-	for core, count := range coresMap {
-		cores = append(cores, core)
-		exclusive = exclusive && count == hwthreadsPerCore
-	}
-
-	return cores, exclusive
-}
-
-// Return a list of memory domain IDs given a list of hwthread IDs.
-// Even if just one hwthread is in that memory domain, add it to the list.
-// If no hwthreads other than those in the argument list are assigned to
-// one of the memory domains in the first return value, return true as the second value.
-// TODO: Optimize this, there must be a more efficient way/algorithm.
-func (topo *Topology) GetMemoryDomainsFromHWThreads(hwthreads []int) (memDoms []int, exclusive bool) {
-	memDomsMap := map[int]int{}
-	for _, hwthread := range hwthreads {
-		for memDom, hwthreadsInmemDom := range topo.MemoryDomain {
-			for _, hwthreadInmemDom := range hwthreadsInmemDom {
-				if hwthread == hwthreadInmemDom {
-					memDomsMap[memDom] += 1
-				}
-			}
-		}
-	}
-
-	exclusive = true
-	hwthreadsPermemDom := len(topo.Node) / len(topo.MemoryDomain)
-	memDoms = make([]int, 0, len(memDomsMap))
-	for memDom, count := range memDomsMap {
-		memDoms = append(memDoms, memDom)
-		exclusive = exclusive && count == hwthreadsPermemDom
-	}
-
-	return memDoms, exclusive
-}
-
-func (topo *Topology) GetAcceleratorIDs() ([]int, error) {
-	accels := make([]int, 0)
-	for _, accel := range topo.Accelerators {
-		id, err := strconv.Atoi(accel.ID)
-		if err != nil {
-			return nil, err
-		}
-		accels = append(accels, id)
-	}
-	return accels, nil
-}
-
-func (topo *Topology) GetAcceleratorIndex(id string) (int, bool) {
-	for idx, accel := range topo.Accelerators {
-		if accel.ID == id {
-			return idx, true
-		}
-	}
-	return -1, false
-}

internal/graph/model/models_gen.go

@@ -11,26 +11,14 @@ import (
 	"github.com/ClusterCockpit/cc-backend/pkg/schema"
 )
 
-type Accelerator struct {
-	ID    string `json:"id"`
-	Type  string `json:"type"`
-	Model string `json:"model"`
-}
-
 type Count struct {
 	Name  string `json:"name"`
 	Count int    `json:"count"`
 }
 
-type FilterRanges struct {
-	Duration  *IntRangeOutput  `json:"duration"`
-	NumNodes  *IntRangeOutput  `json:"numNodes"`
-	StartTime *TimeRangeOutput `json:"startTime"`
-}
-
 type FloatRange struct {
-	From float64 `json:"from"`
-	To   float64 `json:"to"`
+	From schema.Float `json:"from"`
+	To   schema.Float `json:"to"`
 }
 
 type Footprints struct {
@@ -43,11 +31,6 @@ type HistoPoint struct {
 	Value int `json:"value"`
 }
 
-type IntRange struct {
-	From int `json:"from"`
-	To   int `json:"to"`
-}
-
 type IntRangeOutput struct {
 	From int `json:"from"`
 	To   int `json:"to"`
@@ -61,12 +44,12 @@ type JobFilter struct {
 	Project         *StringInput      `json:"project"`
 	Cluster         *StringInput      `json:"cluster"`
 	Partition       *StringInput      `json:"partition"`
-	Duration        *IntRange         `json:"duration"`
+	Duration        *schema.IntRange  `json:"duration"`
 	MinRunningFor   *int              `json:"minRunningFor"`
-	NumNodes        *IntRange         `json:"numNodes"`
-	NumAccelerators *IntRange         `json:"numAccelerators"`
-	NumHWThreads    *IntRange         `json:"numHWThreads"`
-	StartTime       *TimeRange        `json:"startTime"`
+	NumNodes        *schema.IntRange  `json:"numNodes"`
+	NumAccelerators *schema.IntRange  `json:"numAccelerators"`
+	NumHWThreads    *schema.IntRange  `json:"numHWThreads"`
+	StartTime       *schema.TimeRange `json:"startTime"`
 	State           []schema.JobState `json:"state"`
 	FlopsAnyAvg     *FloatRange       `json:"flopsAnyAvg"`
 	MemBwAvg        *FloatRange       `json:"memBwAvg"`
@@ -96,19 +79,6 @@ type JobsStatistics struct {
 	HistNumNodes   []*HistoPoint `json:"histNumNodes"`
 }
 
-type MetricConfig struct {
-	Name        string              `json:"name"`
-	Unit        string              `json:"unit"`
-	Scope       schema.MetricScope  `json:"scope"`
-	Aggregation *string             `json:"aggregation"`
-	Timestep    int                 `json:"timestep"`
-	Peak        *float64            `json:"peak"`
-	Normal      *float64            `json:"normal"`
-	Caution     *float64            `json:"caution"`
-	Alert       *float64            `json:"alert"`
-	SubClusters []*SubClusterConfig `json:"subClusters"`
-}
-
 type MetricFootprints struct {
 	Metric string         `json:"metric"`
 	Data   []schema.Float `json:"data"`
@@ -137,47 +107,11 @@ type StringInput struct {
 	EndsWith   *string `json:"endsWith"`
 }
 
-type SubCluster struct {
-	Name            string    `json:"name"`
-	Nodes           string    `json:"nodes"`
-	NumberOfNodes   int       `json:"numberOfNodes"`
-	ProcessorType   string    `json:"processorType"`
-	SocketsPerNode  int       `json:"socketsPerNode"`
-	CoresPerSocket  int       `json:"coresPerSocket"`
-	ThreadsPerCore  int       `json:"threadsPerCore"`
-	FlopRateScalar  int       `json:"flopRateScalar"`
-	FlopRateSimd    int       `json:"flopRateSimd"`
-	MemoryBandwidth int       `json:"memoryBandwidth"`
-	Topology        *Topology `json:"topology"`
-}
-
-type SubClusterConfig struct {
-	Name    string  `json:"name"`
-	Peak    float64 `json:"peak"`
-	Normal  float64 `json:"normal"`
-	Caution float64 `json:"caution"`
-	Alert   float64 `json:"alert"`
-}
-
-type TimeRange struct {
-	From *time.Time `json:"from"`
-	To   *time.Time `json:"to"`
-}
-
 type TimeRangeOutput struct {
 	From time.Time `json:"from"`
 	To   time.Time `json:"to"`
 }
 
-type Topology struct {
-	Node         []int          `json:"node"`
-	Socket       [][]int        `json:"socket"`
-	MemoryDomain [][]int        `json:"memoryDomain"`
-	Die          [][]int        `json:"die"`
-	Core         [][]int        `json:"core"`
-	Accelerators []*Accelerator `json:"accelerators"`
-}
-
 type User struct {
 	Username string `json:"username"`
 	Name     string `json:"name"`

internal/graph/schema.resolvers.go

@@ -1,7 +1,3 @@
-// Copyright (C) 2022 NHR@FAU, University Erlangen-Nuremberg.
-// All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
 package graph
 
 // This file will be automatically regenerated based on the schema, any resolver implementations
@@ -23,22 +19,82 @@ import (
 	"github.com/ClusterCockpit/cc-backend/pkg/schema"
 )
 
-func (r *clusterResolver) Partitions(ctx context.Context, obj *model.Cluster) ([]string, error) {
+// Partitions is the resolver for the partitions field.
+func (r *clusterResolver) Partitions(ctx context.Context, obj *schema.Cluster) ([]string, error) {
 	return r.Repo.Partitions(obj.Name)
 }
 
+// FilterRanges is the resolver for the filterRanges field.
+func (r *clusterResolver) FilterRanges(ctx context.Context, obj *schema.Cluster) (*schema.FilterRanges, error) {
+	panic(fmt.Errorf("not implemented: FilterRanges - filterRanges"))
+}
+
+// Duration is the resolver for the duration field.
+func (r *filterRangesResolver) Duration(ctx context.Context, obj *schema.FilterRanges) (*model.IntRangeOutput, error) {
+	panic(fmt.Errorf("not implemented: Duration - duration"))
+}
+
+// NumNodes is the resolver for the numNodes field.
+func (r *filterRangesResolver) NumNodes(ctx context.Context, obj *schema.FilterRanges) (*model.IntRangeOutput, error) {
+	panic(fmt.Errorf("not implemented: NumNodes - numNodes"))
+}
+
+// StartTime is the resolver for the startTime field.
+func (r *filterRangesResolver) StartTime(ctx context.Context, obj *schema.FilterRanges) (*model.TimeRangeOutput, error) {
+	panic(fmt.Errorf("not implemented: StartTime - startTime"))
+}
+
+// Tags is the resolver for the tags field.
 func (r *jobResolver) Tags(ctx context.Context, obj *schema.Job) ([]*schema.Tag, error) {
 	return r.Repo.GetTags(&obj.ID)
 }
 
+// MetaData is the resolver for the metaData field.
 func (r *jobResolver) MetaData(ctx context.Context, obj *schema.Job) (interface{}, error) {
 	return r.Repo.FetchMetadata(obj)
 }
 
+// UserData is the resolver for the userData field.
 func (r *jobResolver) UserData(ctx context.Context, obj *schema.Job) (*model.User, error) {
 	return auth.FetchUser(ctx, r.DB, obj.User)
 }
 
+// Peak is the resolver for the peak field.
+func (r *metricConfigResolver) Peak(ctx context.Context, obj *schema.MetricConfig) (*schema.Float, error) {
+	panic(fmt.Errorf("not implemented: Peak - peak"))
+}
+
+// Normal is the resolver for the normal field.
+func (r *metricConfigResolver) Normal(ctx context.Context, obj *schema.MetricConfig) (*schema.Float, error) {
+	panic(fmt.Errorf("not implemented: Normal - normal"))
+}
+
+// Caution is the resolver for the caution field.
+func (r *metricConfigResolver) Caution(ctx context.Context, obj *schema.MetricConfig) (*schema.Float, error) {
+	panic(fmt.Errorf("not implemented: Caution - caution"))
+}
+
+// Alert is the resolver for the alert field.
+func (r *metricConfigResolver) Alert(ctx context.Context, obj *schema.MetricConfig) (*schema.Float, error) {
+	panic(fmt.Errorf("not implemented: Alert - alert"))
+}
+
+// Avg is the resolver for the avg field.
+func (r *metricStatisticsResolver) Avg(ctx context.Context, obj *schema.MetricStatistics) (schema.Float, error) {
+	panic(fmt.Errorf("not implemented: Avg - avg"))
+}
+
+// Min is the resolver for the min field.
+func (r *metricStatisticsResolver) Min(ctx context.Context, obj *schema.MetricStatistics) (schema.Float, error) {
+	panic(fmt.Errorf("not implemented: Min - min"))
+}
+
+// Max is the resolver for the max field.
+func (r *metricStatisticsResolver) Max(ctx context.Context, obj *schema.MetricStatistics) (schema.Float, error) {
+	panic(fmt.Errorf("not implemented: Max - max"))
+}
+
+// CreateTag is the resolver for the createTag field.
 func (r *mutationResolver) CreateTag(ctx context.Context, typeArg string, name string) (*schema.Tag, error) {
 	id, err := r.Repo.CreateTag(typeArg, name)
 	if err != nil {
@@ -48,11 +104,12 @@ func (r *mutationResolver) CreateTag(ctx context.Context, typeArg string, name s
 	return &schema.Tag{ID: id, Type: typeArg, Name: name}, nil
 }
 
+// DeleteTag is the resolver for the deleteTag field.
 func (r *mutationResolver) DeleteTag(ctx context.Context, id string) (string, error) {
-	// The UI does not allow this currently anyways.
-	panic(fmt.Errorf("not implemented"))
+	panic(fmt.Errorf("not implemented: DeleteTag - deleteTag"))
 }
 
+// AddTagsToJob is the resolver for the addTagsToJob field.
 func (r *mutationResolver) AddTagsToJob(ctx context.Context, job string, tagIds []string) ([]*schema.Tag, error) {
 	jid, err := strconv.ParseInt(job, 10, 64)
 	if err != nil {
@@ -74,6 +131,7 @@ func (r *mutationResolver) AddTagsToJob(ctx context.Context, job string, tagIds
 	return tags, nil
 }
 
+// RemoveTagsFromJob is the resolver for the removeTagsFromJob field.
 func (r *mutationResolver) RemoveTagsFromJob(ctx context.Context, job string, tagIds []string) ([]*schema.Tag, error) {
 	jid, err := strconv.ParseInt(job, 10, 64)
 	if err != nil {
@@ -95,7 +153,9 @@ func (r *mutationResolver) RemoveTagsFromJob(ctx context.Context, job string, ta
 	return tags, nil
 }
 
+// UpdateConfiguration is the resolver for the updateConfiguration field.
 func (r *mutationResolver) UpdateConfiguration(ctx context.Context, name string, value string) (*string, error) {
+
 	if err := repository.GetUserCfgRepo().UpdateConfig(name, value, ctx); err != nil {
 		return nil, err
 	}
@@ -103,18 +163,22 @@ func (r *mutationResolver) UpdateConfiguration(ctx context.Context, name string,
 	return nil, nil
 }
 
-func (r *queryResolver) Clusters(ctx context.Context) ([]*model.Cluster, error) {
+// Clusters is the resolver for the clusters field.
+func (r *queryResolver) Clusters(ctx context.Context) ([]*schema.Cluster, error) {
 	return archive.Clusters, nil
 }
 
+// Tags is the resolver for the tags field.
 func (r *queryResolver) Tags(ctx context.Context) ([]*schema.Tag, error) {
 	return r.Repo.GetTags(nil)
 }
 
+// User is the resolver for the user field.
 func (r *queryResolver) User(ctx context.Context, username string) (*model.User, error) {
 	return auth.FetchUser(ctx, r.DB, username)
 }
 
+// AllocatedNodes is the resolver for the allocatedNodes field.
 func (r *queryResolver) AllocatedNodes(ctx context.Context, cluster string) ([]*model.Count, error) {
 	data, err := r.Repo.AllocatedNodes(cluster)
 	if err != nil {
@@ -132,6 +196,7 @@ func (r *queryResolver) AllocatedNodes(ctx context.Context, cluster string) ([]*
 	return counts, nil
 }
 
+// Job is the resolver for the job field.
 func (r *queryResolver) Job(ctx context.Context, id string) (*schema.Job, error) {
 	numericId, err := strconv.ParseInt(id, 10, 64)
 	if err != nil {
@@ -143,13 +208,16 @@ func (r *queryResolver) Job(ctx context.Context, id string) (*schema.Job, error)
 		return nil, err
 	}
 
-	if user := auth.GetUser(ctx); user != nil && !user.HasRole(auth.RoleAdmin) && job.User != user.Username {
+	if user := auth.GetUser(ctx); user != nil &&
+		!user.HasRole(auth.RoleAdmin) &&
+		job.User != user.Username {
 		return nil, errors.New("you are not allowed to see this job")
 	}
 
 	return job, nil
 }
 
+// JobMetrics is the resolver for the jobMetrics field.
 func (r *queryResolver) JobMetrics(ctx context.Context, id string, metrics []string, scopes []schema.MetricScope) ([]*model.JobMetricWithName, error) {
 	job, err := r.Query().Job(ctx, id)
 	if err != nil {
@@ -178,10 +246,12 @@ func (r *queryResolver) JobMetrics(ctx context.Context, id string, metrics []str
 	return res, err
 }
 
+// JobsFootprints is the resolver for the jobsFootprints field.
 func (r *queryResolver) JobsFootprints(ctx context.Context, filter []*model.JobFilter, metrics []string) (*model.Footprints, error) {
 	return r.jobsFootprints(ctx, filter, metrics)
 }
 
+// Jobs is the resolver for the jobs field.
 func (r *queryResolver) Jobs(ctx context.Context, filter []*model.JobFilter, page *model.PageRequest, order *model.OrderByInput) (*model.JobResultList, error) {
 	if page == nil {
 		page = &model.PageRequest{
@@ -203,10 +273,12 @@ func (r *queryResolver) Jobs(ctx context.Context, filter []*model.JobFilter, pag
 	return &model.JobResultList{Items: jobs, Count: &count}, nil
 }
 
+// JobsStatistics is the resolver for the jobsStatistics field.
 func (r *queryResolver) JobsStatistics(ctx context.Context, filter []*model.JobFilter, groupBy *model.Aggregate) ([]*model.JobsStatistics, error) {
 	return r.jobsStatistics(ctx, filter, groupBy)
 }
 
+// JobsCount is the resolver for the jobsCount field.
 func (r *queryResolver) JobsCount(ctx context.Context, filter []*model.JobFilter, groupBy model.Aggregate, weight *model.Weights, limit *int) ([]*model.Count, error) {
 	counts, err := r.Repo.CountGroupedJobs(ctx, groupBy, filter, weight, limit)
 	if err != nil {
@@ -223,10 +295,12 @@ func (r *queryResolver) JobsCount(ctx context.Context, filter []*model.JobFilter
 	return res, nil
 }
 
-func (r *queryResolver) RooflineHeatmap(ctx context.Context, filter []*model.JobFilter, rows int, cols int, minX float64, minY float64, maxX float64, maxY float64) ([][]float64, error) {
+// RooflineHeatmap is the resolver for the rooflineHeatmap field.
+func (r *queryResolver) RooflineHeatmap(ctx context.Context, filter []*model.JobFilter, rows int, cols int, minX schema.Float, minY schema.Float, maxX schema.Float, maxY schema.Float) ([][]schema.Float, error) {
 	return r.rooflineHeatmap(ctx, filter, rows, cols, minX, minY, maxX, maxY)
 }
 
+// NodeMetrics is the resolver for the nodeMetrics field.
 func (r *queryResolver) NodeMetrics(ctx context.Context, cluster string, nodes []string, scopes []schema.MetricScope, metrics []string, from time.Time, to time.Time) ([]*model.NodeMetrics, error) {
 	user := auth.GetUser(ctx)
 	if user != nil && !user.HasRole(auth.RoleAdmin) {
@@ -267,19 +341,59 @@ func (r *queryResolver) NodeMetrics(ctx context.Context, cluster string, nodes [
 	return nodeMetrics, nil
 }
 
+// Peak is the resolver for the peak field.
+func (r *subClusterConfigResolver) Peak(ctx context.Context, obj *schema.SubClusterConfig) (schema.Float, error) {
+	panic(fmt.Errorf("not implemented: Peak - peak"))
+}
+
+// Normal is the resolver for the normal field.
+func (r *subClusterConfigResolver) Normal(ctx context.Context, obj *schema.SubClusterConfig) (schema.Float, error) {
+	panic(fmt.Errorf("not implemented: Normal - normal"))
+}
+
+// Caution is the resolver for the caution field.
+func (r *subClusterConfigResolver) Caution(ctx context.Context, obj *schema.SubClusterConfig) (schema.Float, error) {
+	panic(fmt.Errorf("not implemented: Caution - caution"))
+}
+
+// Alert is the resolver for the alert field.
+func (r *subClusterConfigResolver) Alert(ctx context.Context, obj *schema.SubClusterConfig) (schema.Float, error) {
+	panic(fmt.Errorf("not implemented: Alert - alert"))
+}
+
 // Cluster returns generated.ClusterResolver implementation.
 func (r *Resolver) Cluster() generated.ClusterResolver { return &clusterResolver{r} }
 
+// FilterRanges returns generated.FilterRangesResolver implementation.
+func (r *Resolver) FilterRanges() generated.FilterRangesResolver { return &filterRangesResolver{r} }
+
 // Job returns generated.JobResolver implementation.
 func (r *Resolver) Job() generated.JobResolver { return &jobResolver{r} }
 
+// MetricConfig returns generated.MetricConfigResolver implementation.
+func (r *Resolver) MetricConfig() generated.MetricConfigResolver { return &metricConfigResolver{r} }
+
+// MetricStatistics returns generated.MetricStatisticsResolver implementation.
+func (r *Resolver) MetricStatistics() generated.MetricStatisticsResolver {
+	return &metricStatisticsResolver{r}
+}
+
 // Mutation returns generated.MutationResolver implementation.
 func (r *Resolver) Mutation() generated.MutationResolver { return &mutationResolver{r} }
 
 // Query returns generated.QueryResolver implementation.
 func (r *Resolver) Query() generated.QueryResolver { return &queryResolver{r} }
 
+// SubClusterConfig returns generated.SubClusterConfigResolver implementation.
+func (r *Resolver) SubClusterConfig() generated.SubClusterConfigResolver {
+	return &subClusterConfigResolver{r}
+}
+
 type clusterResolver struct{ *Resolver }
+type filterRangesResolver struct{ *Resolver }
 type jobResolver struct{ *Resolver }
+type metricConfigResolver struct{ *Resolver }
+type metricStatisticsResolver struct{ *Resolver }
 type mutationResolver struct{ *Resolver }
 type queryResolver struct{ *Resolver }
+type subClusterConfigResolver struct{ *Resolver }

internal/graph/stats.go

@@ -200,7 +200,17 @@ func (r *queryResolver) jobsStatisticsHistogram(ctx context.Context, value strin
 const MAX_JOBS_FOR_ANALYSIS = 500
 
 // Helper function for the rooflineHeatmap GraphQL query placed here so that schema.resolvers.go is not too full.
-func (r *Resolver) rooflineHeatmap(ctx context.Context, filter []*model.JobFilter, rows int, cols int, minX float64, minY float64, maxX float64, maxY float64) ([][]float64, error) {
+func (r *queryResolver) rooflineHeatmap(
+	ctx context.Context,
+	filter []*model.JobFilter,
+	rows int, cols int,
+	minXF schema.Float, minYF schema.Float, maxXF schema.Float, maxYF schema.Float) ([][]schema.Float, error) {
+
+	var minX, minY, maxX, maxY float64
+	minX = float64(minXF)
+	minY = float64(minYF)
+	maxX = float64(maxXF)
+	maxY = float64(maxYF)
 	jobs, err := r.Repo.QueryJobs(ctx, filter, &model.PageRequest{Page: 1, ItemsPerPage: MAX_JOBS_FOR_ANALYSIS + 1}, nil)
 	if err != nil {
 		return nil, err
@@ -211,9 +221,9 @@ func (r *Resolver) rooflineHeatmap(ctx context.Context, filter []*model.JobFilte
 
 	fcols, frows := float64(cols), float64(rows)
 	minX, minY, maxX, maxY = math.Log10(minX), math.Log10(minY), math.Log10(maxX), math.Log10(maxY)
-	tiles := make([][]float64, rows)
+	tiles := make([][]schema.Float, rows)
 	for i := range tiles {
-		tiles[i] = make([]float64, cols)
+		tiles[i] = make([]schema.Float, cols)
 	}
 
 	for _, job := range jobs {