Merge pull request #2056 from mfranczy/hugepages

Introduce memory.hugepages feature

Author: k8s-ci-robot

docs/usage/customization-guide.md

@@ -966,6 +966,9 @@ The following features are available for matching:
 |                  |              | **`node_count`** | int | Number of NUMA nodes |
 | **`memory.swap`**  | attribute  |          |            | Swap enabled on node |
 |                  |              | **`enabled`** | bool  | `true` if swap partition detected, `false` otherwise |
+| **`memory.hugepages`**  | attribute  |          |       | Discovery of supported huge pages size on node |
+|                  |              | **`enabled`** | bool  | `true` if total number of huge pages (of any page size) have been configured, otherwise `false` |
+|                  |              | **`hugepages-<page-size>`** | string   | total number of huge pages (e.g., `hugepages-1Gi=16`) |
 | **`network.device`** | instance |          |            | Physical (non-virtual) network interfaces present in the system |
 |                  |              | **`name`** | string   | Name of the network interface |
 |                  |              | **`<sysfs-attribute>`** | string | Sysfs network interface attribute, available attributes: `operstate`, `speed`, `sriov_numvfs`, `sriov_totalvfs` |

source/memory/memory.go

@@ -17,12 +17,15 @@ limitations under the License.
 package memory
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
 
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
 	"k8s.io/klog/v2"
 
 	nfdv1alpha1 "sigs.k8s.io/node-feature-discovery/api/nfd/v1alpha1"
@@ -40,9 +43,12 @@ const NvFeature = "nv"
 // NumaFeature is the name of the feature set that holds all NUMA related features.
 const NumaFeature = "numa"
 
-// SwapFeature is the name of the feature set that holds all Swap related features
+// SwapFeature is the name of the feature set that holds all Swap related features.
 const SwapFeature = "swap"
 
+// HugePages is the name of the feature set that holds information about huge pages.
+const HugePages = "hugepages"
+
 // memorySource implements the FeatureSource and LabelSource interfaces.
 type memorySource struct {
 	features *nfdv1alpha1.Features
@@ -115,6 +121,13 @@ func (s *memorySource) Discover() error {
 		s.features.Instances[NvFeature] = nfdv1alpha1.InstanceFeatureSet{Elements: nv}
 	}
 
+	// Detect Huge Pages
+	if hp, err := detectHugePages(); err != nil {
+		klog.ErrorS(err, "failed to detect huge pages")
+	} else {
+		s.features.Attributes[HugePages] = nfdv1alpha1.AttributeFeatureSet{Elements: hp}
+	}
+
 	klog.V(3).InfoS("discovered features", "featureSource", s.Name(), "features", utils.DelayedDumper(s.features))
 
 	return nil
@@ -179,6 +192,57 @@ func detectNv() ([]nfdv1alpha1.InstanceFeature, error) {
 	return info, nil
 }
 
+// detectHugePages checks whether huge pages are enabled on the node
+// and retrieves the configured huge page sizes.
+func detectHugePages() (map[string]string, error) {
+	hugePages := map[string]string{
+		"enabled": "false",
+	}
+
+	basePath := hostpath.SysfsDir.Path("kernel/mm/hugepages")
+	subdirs, err := os.ReadDir(basePath)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return hugePages, nil
+		}
+		return nil, fmt.Errorf("unable to read huge pages size: %w", err)
+	}
+
+	for _, entry := range subdirs {
+		if !entry.IsDir() {
+			continue
+		}
+
+		totalPages, err := getHugePagesTotalCount(basePath, entry.Name())
+		if err != nil {
+			klog.ErrorS(err, "unable to read hugepages total count", "hugepages", entry.Name())
+		}
+		pageSize := strings.TrimRight(strings.TrimPrefix(entry.Name(), "hugepages-"), "kB")
+		quantity, err := resource.ParseQuantity(pageSize + "Ki")
+		if err != nil {
+			klog.ErrorS(err, "unable to parse quantity", "hugepages", entry.Name(), "pageSize", pageSize)
+			continue
+		}
+
+		hugePages[corev1.ResourceHugePagesPrefix+quantity.String()] = totalPages
+		if v, err := strconv.Atoi(totalPages); err == nil && v > 0 {
+			hugePages["enabled"] = "true"
+		}
+	}
+
+	return hugePages, nil
+}
+
+func getHugePagesTotalCount(basePath, dirname string) (string, error) {
+	totalPagesFile := filepath.Join(basePath, dirname, "nr_hugepages")
+	totalPages, err := os.ReadFile(totalPagesFile)
+	if err != nil {
+		return "", fmt.Errorf("unable to read total number of huge pages from the file: %s", totalPagesFile)
+	}
+
+	return strings.TrimSpace(string(totalPages)), nil
+}
+
 // ndDevAttrs is the list of sysfs files (under each nd device) that we're trying to read
 var ndDevAttrs = []string{"devtype", "mode"}
 

source/memory/memory_test.go

@@ -19,7 +19,10 @@ package memory
 import (
 	"testing"
 
+	. "github.com/smartystreets/goconvey/convey"
 	"github.com/stretchr/testify/assert"
+
+	"sigs.k8s.io/node-feature-discovery/pkg/utils/hostpath"
 )
 
 func TestMemorySource(t *testing.T) {
@@ -61,3 +64,53 @@ func TestGetNumberofLinesFromFile(t *testing.T) {
 		assert.Equal(t, tc.expectedLines, actual, "lines should match")
 	}
 }
+
+func TestDetectHugePages(t *testing.T) {
+
+	Convey("With configured 1Gi huge pages size", t, func() {
+		hostpath.SysfsDir = "testdata/hugepages"
+
+		expectedHugePages := map[string]string{
+			"enabled":       "true",
+			"hugepages-1Gi": "2",
+			"hugepages-2Mi": "0",
+		}
+		hugePages, err := detectHugePages()
+		assert.Nil(t, err)
+		assert.Equal(t, hugePages, expectedHugePages)
+	})
+
+	Convey("With invalid directory structure", t, func() {
+		hostpath.SysfsDir = "invalid-dir"
+
+		expectedHugePages := map[string]string{
+			"enabled": "false",
+		}
+		hugePages, err := detectHugePages()
+		assert.Nil(t, err)
+		assert.Equal(t, hugePages, expectedHugePages)
+	})
+
+}
+
+func TestGetHugePagesTotalCount(t *testing.T) {
+
+	Convey("With configured total huge pages", t, func() {
+		totalPages, err := getHugePagesTotalCount("testdata/hugepages/kernel/mm/hugepages", "hugepages-1048576kB")
+		assert.Equal(t, "2", totalPages)
+		assert.Nil(t, err)
+	})
+
+	Convey("With not configured total huge pages", t, func() {
+		totalPages, err := getHugePagesTotalCount("testdata/hugepages/kernel/mm/hugepages", "hugepages-2048kB")
+		assert.Equal(t, "0", totalPages)
+		assert.Nil(t, err)
+	})
+
+	Convey("With invalid huge page directory", t, func() {
+		totalPages, err := getHugePagesTotalCount("testdata/hugepages/kernel/mm/hugepages", "hugepages-invalid")
+		assert.Equal(t, "", totalPages)
+		assert.NotNil(t, err)
+	})
+
+}

source/memory/testdata/hugepages/kernel/mm/hugepages/hugepages-1048576kB/nr_hugepages

@@ -0,0 +1 @@
+2

source/memory/testdata/hugepages/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages

@@ -0,0 +1 @@
+0