github.com/zhuohuang-hust/src-cbuild@v0.0.0-20230105071821-c7aab3e7c840/mergeCode/runc/libcontainer/cgroups/fs/hugetlb_test.go (about)

     1  // +build linux
     2  
     3  package fs
     4  
     5  import (
     6  	"fmt"
     7  	"strconv"
     8  	"testing"
     9  
    10  	"github.com/opencontainers/runc/libcontainer/cgroups"
    11  	"github.com/opencontainers/runc/libcontainer/configs"
    12  )
    13  
    14  const (
    15  	hugetlbUsageContents    = "128\n"
    16  	hugetlbMaxUsageContents = "256\n"
    17  	hugetlbFailcnt          = "100\n"
    18  )
    19  
    20  var (
    21  	usage    = "hugetlb.%s.usage_in_bytes"
    22  	limit    = "hugetlb.%s.limit_in_bytes"
    23  	maxUsage = "hugetlb.%s.max_usage_in_bytes"
    24  	failcnt  = "hugetlb.%s.failcnt"
    25  )
    26  
    27  func TestHugetlbSetHugetlb(t *testing.T) {
    28  	helper := NewCgroupTestUtil("hugetlb", t)
    29  	defer helper.cleanup()
    30  
    31  	const (
    32  		hugetlbBefore = 256
    33  		hugetlbAfter  = 512
    34  	)
    35  
    36  	for _, pageSize := range HugePageSizes {
    37  		helper.writeFileContents(map[string]string{
    38  			fmt.Sprintf(limit, pageSize): strconv.Itoa(hugetlbBefore),
    39  		})
    40  	}
    41  
    42  	for _, pageSize := range HugePageSizes {
    43  		helper.CgroupData.config.Resources.HugetlbLimit = []*configs.HugepageLimit{
    44  			{
    45  				Pagesize: pageSize,
    46  				Limit:    hugetlbAfter,
    47  			},
    48  		}
    49  		hugetlb := &HugetlbGroup{}
    50  		if err := hugetlb.Set(helper.CgroupPath, helper.CgroupData.config); err != nil {
    51  			t.Fatal(err)
    52  		}
    53  	}
    54  
    55  	for _, pageSize := range HugePageSizes {
    56  		limit := fmt.Sprintf(limit, pageSize)
    57  		value, err := getCgroupParamUint(helper.CgroupPath, limit)
    58  		if err != nil {
    59  			t.Fatalf("Failed to parse %s - %s", limit, err)
    60  		}
    61  		if value != hugetlbAfter {
    62  			t.Fatalf("Set hugetlb.limit_in_bytes failed. Expected: %v, Got: %v", hugetlbAfter, value)
    63  		}
    64  	}
    65  }
    66  
    67  func TestHugetlbStats(t *testing.T) {
    68  	helper := NewCgroupTestUtil("hugetlb", t)
    69  	defer helper.cleanup()
    70  	for _, pageSize := range HugePageSizes {
    71  		helper.writeFileContents(map[string]string{
    72  			fmt.Sprintf(usage, pageSize):    hugetlbUsageContents,
    73  			fmt.Sprintf(maxUsage, pageSize): hugetlbMaxUsageContents,
    74  			fmt.Sprintf(failcnt, pageSize):  hugetlbFailcnt,
    75  		})
    76  	}
    77  
    78  	hugetlb := &HugetlbGroup{}
    79  	actualStats := *cgroups.NewStats()
    80  	err := hugetlb.GetStats(helper.CgroupPath, &actualStats)
    81  	if err != nil {
    82  		t.Fatal(err)
    83  	}
    84  	expectedStats := cgroups.HugetlbStats{Usage: 128, MaxUsage: 256, Failcnt: 100}
    85  	for _, pageSize := range HugePageSizes {
    86  		expectHugetlbStatEquals(t, expectedStats, actualStats.HugetlbStats[pageSize])
    87  	}
    88  }
    89  
    90  func TestHugetlbStatsNoUsageFile(t *testing.T) {
    91  	helper := NewCgroupTestUtil("hugetlb", t)
    92  	defer helper.cleanup()
    93  	helper.writeFileContents(map[string]string{
    94  		maxUsage: hugetlbMaxUsageContents,
    95  	})
    96  
    97  	hugetlb := &HugetlbGroup{}
    98  	actualStats := *cgroups.NewStats()
    99  	err := hugetlb.GetStats(helper.CgroupPath, &actualStats)
   100  	if err == nil {
   101  		t.Fatal("Expected failure")
   102  	}
   103  }
   104  
   105  func TestHugetlbStatsNoMaxUsageFile(t *testing.T) {
   106  	helper := NewCgroupTestUtil("hugetlb", t)
   107  	defer helper.cleanup()
   108  	for _, pageSize := range HugePageSizes {
   109  		helper.writeFileContents(map[string]string{
   110  			fmt.Sprintf(usage, pageSize): hugetlbUsageContents,
   111  		})
   112  	}
   113  
   114  	hugetlb := &HugetlbGroup{}
   115  	actualStats := *cgroups.NewStats()
   116  	err := hugetlb.GetStats(helper.CgroupPath, &actualStats)
   117  	if err == nil {
   118  		t.Fatal("Expected failure")
   119  	}
   120  }
   121  
   122  func TestHugetlbStatsBadUsageFile(t *testing.T) {
   123  	helper := NewCgroupTestUtil("hugetlb", t)
   124  	defer helper.cleanup()
   125  	for _, pageSize := range HugePageSizes {
   126  		helper.writeFileContents(map[string]string{
   127  			fmt.Sprintf(usage, pageSize): "bad",
   128  			maxUsage:                     hugetlbMaxUsageContents,
   129  		})
   130  	}
   131  
   132  	hugetlb := &HugetlbGroup{}
   133  	actualStats := *cgroups.NewStats()
   134  	err := hugetlb.GetStats(helper.CgroupPath, &actualStats)
   135  	if err == nil {
   136  		t.Fatal("Expected failure")
   137  	}
   138  }
   139  
   140  func TestHugetlbStatsBadMaxUsageFile(t *testing.T) {
   141  	helper := NewCgroupTestUtil("hugetlb", t)
   142  	defer helper.cleanup()
   143  	helper.writeFileContents(map[string]string{
   144  		usage:    hugetlbUsageContents,
   145  		maxUsage: "bad",
   146  	})
   147  
   148  	hugetlb := &HugetlbGroup{}
   149  	actualStats := *cgroups.NewStats()
   150  	err := hugetlb.GetStats(helper.CgroupPath, &actualStats)
   151  	if err == nil {
   152  		t.Fatal("Expected failure")
   153  	}
   154  }