buildtools: support COFF in pmdinfogen
[dpdk.git] / usertools / dpdk-hugepages.py
1 #! /usr/bin/env python3
2 # SPDX-License-Identifier: BSD-3-Clause
3 # Copyright (c) 2020 Microsoft Corporation
4 """Script to query and setup huge pages for DPDK applications."""
5
6 import argparse
7 import glob
8 import os
9 import re
10 import sys
11 from math import log2
12
13 # Standard binary prefix
14 BINARY_PREFIX = "KMG"
15
16 # systemd mount point for huge pages
17 HUGE_MOUNT = "/dev/hugepages"
18
19
20 def fmt_memsize(kb):
21     '''Format memory size in kB into conventional format'''
22     logk = int(log2(kb) / 10)
23     suffix = BINARY_PREFIX[logk]
24     unit = 2**(logk * 10)
25     return '{}{}b'.format(int(kb / unit), suffix)
26
27
28 def get_memsize(arg):
29     '''Convert memory size with suffix to kB'''
30     match = re.match(r'(\d+)([' + BINARY_PREFIX + r']?)$', arg.upper())
31     if match is None:
32         sys.exit('{} is not a valid page size'.format(arg))
33     num = float(match.group(1))
34     suffix = match.group(2)
35     if suffix == "":
36         return int(num / 1024)
37     idx = BINARY_PREFIX.find(suffix)
38     return int(num * (2**(idx * 10)))
39
40
41 def is_numa():
42     '''Test if NUMA is necessary on this system'''
43     return os.path.exists('/sys/devices/system/node')
44
45
46 def get_hugepages(path):
47     '''Read number of reserved pages'''
48     with open(path + '/nr_hugepages') as nr_hugepages:
49         return int(nr_hugepages.read())
50     return 0
51
52
53 def set_hugepages(path, pages):
54     '''Write the number of reserved huge pages'''
55     filename = path + '/nr_hugepages'
56     try:
57         with open(filename, 'w') as nr_hugepages:
58             nr_hugepages.write('{}\n'.format(pages))
59     except PermissionError:
60         sys.exit('Permission denied: need to be root!')
61     except FileNotFoundError:
62         filename = os.path.basename(path)
63         size = filename[10:]
64         sys.exit('{} is not a valid system huge page size'.format(size))
65
66
67 def show_numa_pages():
68     '''Show huge page reservations on Numa system'''
69     print('Node Pages Size Total')
70     for numa_path in glob.glob('/sys/devices/system/node/node*'):
71         node = numa_path[29:]  # slice after /sys/devices/system/node/node
72         path = numa_path + '/hugepages'
73         for hdir in os.listdir(path):
74             pages = get_hugepages(path + '/' + hdir)
75             if pages > 0:
76                 kb = int(hdir[10:-2])  # slice out of hugepages-NNNkB
77                 print('{:<4} {:<5} {:<6} {}'.format(node, pages,
78                                                     fmt_memsize(kb),
79                                                     fmt_memsize(pages * kb)))
80
81
82 def show_non_numa_pages():
83     '''Show huge page reservations on non Numa system'''
84     print('Pages Size Total')
85     path = '/sys/kernel/mm/hugepages'
86     for hdir in os.listdir(path):
87         pages = get_hugepages(path + '/' + hdir)
88         if pages > 0:
89             kb = int(hdir[10:-2])
90             print('{:<5} {:<6} {}'.format(pages, fmt_memsize(kb),
91                                           fmt_memsize(pages * kb)))
92
93
94 def show_pages():
95     '''Show existing huge page settings'''
96     if is_numa():
97         show_numa_pages()
98     else:
99         show_non_numa_pages()
100
101
102 def clear_pages():
103     '''Clear all existing huge page mappings'''
104     if is_numa():
105         dirs = glob.glob(
106             '/sys/devices/system/node/node*/hugepages/hugepages-*')
107     else:
108         dirs = glob.glob('/sys/kernel/mm/hugepages/hugepages-*')
109
110     for path in dirs:
111         set_hugepages(path, 0)
112
113
114 def default_pagesize():
115     '''Get default huge page size from /proc/meminfo'''
116     with open('/proc/meminfo') as meminfo:
117         for line in meminfo:
118             if line.startswith('Hugepagesize:'):
119                 return int(line.split()[1])
120     return None
121
122
123 def set_numa_pages(pages, hugepgsz, node=None):
124     '''Set huge page reservation on Numa system'''
125     if node:
126         nodes = ['/sys/devices/system/node/node{}/hugepages'.format(node)]
127     else:
128         nodes = glob.glob('/sys/devices/system/node/node*/hugepages')
129
130     for node_path in nodes:
131         huge_path = '{}/hugepages-{}kB'.format(node_path, hugepgsz)
132         set_hugepages(huge_path, pages)
133
134
135 def set_non_numa_pages(pages, hugepgsz):
136     '''Set huge page reservation on non Numa system'''
137     path = '/sys/kernel/mm/hugepages/hugepages-{}kB'.format(hugepgsz)
138     set_hugepages(path, pages)
139
140
141 def reserve_pages(pages, hugepgsz, node=None):
142     '''Set the number of huge pages to be reserved'''
143     if node or is_numa():
144         set_numa_pages(pages, hugepgsz, node=node)
145     else:
146         set_non_numa_pages(pages, hugepgsz)
147
148
149 def get_mountpoints():
150     '''Get list of where hugepage filesystem is mounted'''
151     mounted = []
152     with open('/proc/mounts') as mounts:
153         for line in mounts:
154             fields = line.split()
155             if fields[2] != 'hugetlbfs':
156                 continue
157             mounted.append(fields[1])
158     return mounted
159
160
161 def mount_huge(pagesize, mountpoint):
162     '''Mount the huge TLB file system'''
163     if mountpoint in get_mountpoints():
164         print(mountpoint, "already mounted")
165         return
166     cmd = "mount -t hugetlbfs"
167     if pagesize:
168         cmd += ' -o pagesize={}'.format(pagesize * 1024)
169     cmd += ' nodev ' + mountpoint
170     os.system(cmd)
171
172
173 def umount_huge(mountpoint):
174     '''Unmount the huge TLB file system (if mounted)'''
175     if mountpoint in get_mountpoints():
176         os.system("umount " + mountpoint)
177
178
179 def show_mount():
180     '''Show where huge page filesystem is mounted'''
181     mounted = get_mountpoints()
182     if mounted:
183         print("Hugepages mounted on", *mounted)
184     else:
185         print("Hugepages not mounted")
186
187
188 def main():
189     '''Process the command line arguments and setup huge pages'''
190     parser = argparse.ArgumentParser(
191         formatter_class=argparse.RawDescriptionHelpFormatter,
192         description="Setup huge pages",
193         epilog="""
194 Examples:
195
196 To display current huge page settings:
197     %(prog)s -s
198
199 To a complete setup of with 2 Gigabyte of 1G huge pages:
200     %(prog)s -p 1G --setup 2G
201 """)
202     parser.add_argument(
203         '--show',
204         '-s',
205         action='store_true',
206         help="print the current huge page configuration")
207     parser.add_argument(
208         '--clear', '-c', action='store_true', help="clear existing huge pages")
209     parser.add_argument(
210         '--mount',
211         '-m',
212         action='store_true',
213         help='mount the huge page filesystem')
214     parser.add_argument(
215         '--unmount',
216         '-u',
217         action='store_true',
218         help='unmount the system huge page directory')
219     parser.add_argument(
220         '--node', '-n', help='select numa node to reserve pages on')
221     parser.add_argument(
222         '--pagesize',
223         '-p',
224         metavar='SIZE',
225         help='choose huge page size to use')
226     parser.add_argument(
227         '--reserve',
228         '-r',
229         metavar='SIZE',
230         help='reserve huge pages. Size is in bytes with K, M, or G suffix')
231     parser.add_argument(
232         '--setup',
233         metavar='SIZE',
234         help='setup huge pages by doing clear, unmount, reserve and mount')
235     args = parser.parse_args()
236
237     if args.setup:
238         args.clear = True
239         args.unmount = True
240         args.reserve = args.setup
241         args.mount = True
242
243     if args.pagesize:
244         pagesize_kb = get_memsize(args.pagesize)
245     else:
246         pagesize_kb = default_pagesize()
247
248     if args.clear:
249         clear_pages()
250     if args.unmount:
251         umount_huge(HUGE_MOUNT)
252
253     if args.reserve:
254         reserve_kb = get_memsize(args.reserve)
255         if reserve_kb % pagesize_kb != 0:
256             sys.exit(
257                 'Huge reservation {}kB is not a multiple of page size {}kB'.
258                 format(reserve_kb, pagesize_kb))
259         reserve_pages(
260             int(reserve_kb / pagesize_kb), pagesize_kb, node=args.node)
261     if args.mount:
262         mount_huge(pagesize_kb, HUGE_MOUNT)
263     if args.show:
264         show_pages()
265         print()
266         show_mount()
267
268
269 if __name__ == "__main__":
270     main()