perf record: adapt NUMA awareness to machines with #CPUs > 1K
Subsystems (2)
v3 cover perf record: adapt NUMA awareness to machines with #CPUs > 1K
Current implementation of cpu_set_t type by glibc has internal cpu mask size limitation of no more than 1024 CPUs. This limitation confines NUMA awareness of Perf tool in record mode, thru --affinity option, to the first 1024 CPUs on machines with larger amount of CPUs.
This patch set enables Perf tool to overcome 1024 CPUs limitation by using a dedicated struct mmap_cpu_mask type and applying tool's bitmap API operations to manipulate affinity masks of the tool's thread and the mmaped data buffers.
tools bitmap API has been extended with bitmap_free() function and bitmap_equal() operation whose implementation is derived from the kernel one.
---
Alexey Budankov (3):
tools bitmap: implement bitmap_equal() operation at bitmap API perf mmap: declare type for cpu mask of arbitrary length perf record: adapt affinity to machines with #CPUs > 1K
tools/include/linux/bitmap.h | 30 +++++++++++++++++++++++++++ tools/lib/bitmap.c | 15 ++++++++++++++ tools/perf/builtin-record.c | 27 ++++++++++++++++++------ tools/perf/util/mmap.c | 40 ++++++++++++++++++++++++++++++------ tools/perf/util/mmap.h | 13 +++++++++++- 5 files changed, 112 insertions(+), 13 deletions(-)
---
Changes in v3:
- implemented perf_mmap__print_cpu_mask() function
- use perf_mmap__print_cpu_mask() to log thread and mmap cpus masks when verbose level is equal to 2
Changes in v2:
- implemented bitmap_free() for symmetry with bitmap_alloc()
- capitalized MMAP_CPU_MASK_BYTES() macro
- returned -1 from perf_mmap__setup_affinity_mask()
- implemented releasing of masks using bitmap_free()
- moved debug printing under -vv option
---
Testing:
tools/perf/perf record -vv --affinity=cpu -- ls
thread mask[8]: empty
...
------------------------------------------------------------perf_event_attr:
...
mmap size 528384B0x7fddecf760b8: mmap mask[8]: 00x7fddecf86180: mmap mask[8]: 10x7fddecf96248: mmap mask[8]: 20x7fddecfa6310: mmap mask[8]: 30x7fddecfb63d8: mmap mask[8]: 40x7fddecfc64a0: mmap mask[8]: 50x7fddecfd6568: mmap mask[8]: 60x7fddecfe6630: mmap mask[8]: 7
------------------------------------------------------------perf_event_attr:
...
Synthesizing TSC conversion information0x7fddecf760b8: thread mask[8]: 00x7fddecf86180: thread mask[8]: 10x7fddecf96248: thread mask[8]: 2
arch copy Documentation init kernel MAINTAINERS modules.builtin.modinfo perf.data scripts System.map vmlinux block COPYING drivers ipc lbuild Makefile modules.order perf.data.old security tools vmlinux.o
certs CREDITS fs Kbuild lib mm Module.symvers README sound usr
config-5.2.7-100.fc29.x86_64 crypto include Kconfig LICENSES modules.builtin net samples stdio virt0x7fddecfa6310: thread mask[8]: 30x7fddecfb63d8: thread mask[8]: 40x7fddecfc64a0: thread mask[8]: 50x7fddecfd6568: thread mask[8]: 60x7fddecfe6630: thread mask[8]: 70x7fddecf760b8: thread mask[8]: 00x7fddecf86180: thread mask[8]: 10x7fddecf96248: thread mask[8]: 20x7fddecfa6310: thread mask[8]: 30x7fddecfb63d8: thread mask[8]: 40x7fddecfc64a0: thread mask[8]: 50x7fddecfd6568: thread mask[8]: 60x7fddecfe6630: thread mask[8]: 7
[ perf record: Woken up 0 times to write data ] 0x7fddecf760b8: thread mask[8]: 00x7fddecf86180: thread mask[8]: 10x7fddecf96248: thread mask[8]: 20x7fddecfa6310: thread mask[8]: 30x7fddecfb63d8: thread mask[8]: 40x7fddecfc64a0: thread mask[8]: 50x7fddecfd6568: thread mask[8]: 60x7fddecfe6630: thread mask[8]: 7
Looking at the vmlinux_path (8 entries long)
Using vmlinux for symbols
[ perf record: Captured and wrote 0.014 MB perf.data (8 samples) ]
Signature · 1 line
2.20.1
PATCH v3 1/3 tools bitmap: implement bitmap_equal() operation at bitmap API
Extend tools bitmap API with bitmap_equal() implementation. The implementation has been derived from the kernel.
Extend tools bitmap API with bitmap_free() implementation for symmetry with bitmap_alloc() function.
--- tools/include/linux/bitmap.h | 30 ++++++++++++++++++++++++++++++ tools/lib/bitmap.c | 15 +++++++++++++++ 2 files changed, 45 insertions(+)
tools/include/linux/bitmap.h +30 -0
@@ -15,6 +15,8 @@ void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1, const unsigned long *bitmap2, int bits);int __bitmap_and (unsigned long *dst,const unsigned long *bitmap1,const unsigned long *bitmap2,unsigned int bits); +int __bitmap_equal (const unsigned long *bitmap1, +const unsigned long *bitmap2,unsigned int bits);void bitmap_clear (unsigned long *map,unsigned int start,int len);#define BITMAP_FIRST_WORD_MASK (start) (~0UL << ((start) & (BITS_PER_LONG - 1)))
@@ -123,6 +125,15 @@ static inline unsigned long *bitmap_alloc(int nbits)return calloc (1 ,BITS_TO_LONGS (nbits) *sizeof (unsigned long )); } +/* +* bitmap_free - Free bitmap +* @bitmap: pointer to bitmap +*/ +static inline void bitmap_free (unsigned long *bitmap) +{ +free (bitmap); +} +/* * bitmap_scnprintf - print bitmap list into buffer * @bitmap: bitmap
@@ -148,4 +159,23 @@ static inline int bitmap_and(unsigned long *dst, const unsigned long *src1, return __bitmap_and(dst, src1, src2, nbits); } +#ifdef __LITTLE_ENDIAN +#define BITMAP_MEM_ALIGNMENT 8 +#else +#define BITMAP_MEM_ALIGNMENT (8 * sizeof(unsigned long)) +#endif +#define BITMAP_MEM_MASK (BITMAP_MEM_ALIGNMENT - 1) +#define IS_ALIGNED (x, a) (((x) & ((typeof(x))(a) - 1)) == 0) + +static inline int bitmap_equal (const unsigned long *src1, +const unsigned long *src2,unsigned int nbits) +{ +if (small_const_nbits (nbits)) +return !((*src1 ^ *src2) &BITMAP_LAST_WORD_MASK (nbits)); +if (__builtin_constant_p (nbits &BITMAP_MEM_MASK ) && +IS_ALIGNED (nbits,BITMAP_MEM_ALIGNMENT )) +return !memcmp (src1, src2, nbits /8 ); +return __bitmap_equal (src1, src2, nbits); +} +#endif /* _PERF_BITOPS_H */
tools/lib/bitmap.c +15 -0
@@ -71,3 +71,18 @@ int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1, BITMAP_LAST_WORD_MASK(bits));return result !=0 ; } + +int __bitmap_equal (const unsigned long *bitmap1, +const unsigned long *bitmap2,unsigned int bits) +{ +unsigned int k, lim = bits/BITS_PER_LONG ; +for (k =0 ; k < lim; ++k) +if (bitmap1[k] != bitmap2[k]) +return 0 ; + +if (bits %BITS_PER_LONG ) +if ((bitmap1[k] ^ bitmap2[k]) &BITMAP_LAST_WORD_MASK (bits)) +return 0 ; + +return 1 ; +}
Signature · 1 line
2.20.1
PATCH v3 2/3 perf mmap: declare type for cpu mask of arbitrary length
In reply to Alexey BudankovDeclare a dedicated struct map_cpu_mask type for cpu masks of arbitrary length. Mask is available thru bits pointer and the mask length is kept in nbits field. MMAP_CPU_MASK_BYTES() macro returns mask storage size in bytes. perf_mmap__print_cpu_mask() function can be used to log text representation of the mask.
--- tools/perf/util/mmap.c | 12 ++++++++++++ tools/perf/util/mmap.h | 11 +++++++++++ 2 files changed, 23 insertions(+)
tools/perf/util/mmap.c +12 -0
@@ -23,6 +23,18 @@#include "mmap.h" #include "../perf.h" #include <internal/lib.h> /* page_size */ +#include <linux/bitmap.h> + +#define MASK_SIZE 1023 +void perf_mmap__print_cpu_mask (struct mmap_cpu_mask *mask,const char *tag) +{ +char buf[MASK_SIZE +1 ]; +size_t len; + + len =bitmap_scnprintf (mask->bits, mask->nbits, buf,MASK_SIZE ); + buf[len] ='\0' ; +pr_debug ("%p: %s mask[%ld]: %s\n" , mask, tag, mask->nbits, buf); +}size_t mmap__mmap_len (struct mmap *map) {
tools/perf/util/mmap.h +11 -0
@@ -15,6 +15,15 @@#include "event.h" struct aiocb ; + +struct mmap_cpu_mask { +unsigned long *bits; +size_t nbits; +}; + +#define MMAP_CPU_MASK_BYTES (m) \ + (BITS_TO_LONGS(((struct mmap_cpu_mask *)m)->nbits) * sizeof(unsigned long)) +/** * struct mmap - perf's ring buffer mmap details *
@@ -52,4 +61,6 @@ int perf_mmap__push(struct mmap *md, void *to,size_t mmap__mmap_len (struct mmap *map); +void perf_mmap__print_cpu_mask (struct mmap_cpu_mask *mask,const char *tag); +#endif /*__PERF_MMAP_H */
Signature · 1 line
2.20.1
Re: [PATCH v3 2/3] perf mmap: declare type for cpu mask of arbitrary length
Quoted 18 lines · Alexey Budankov
Declare a dedicated struct
map_cpu_masktype for cpu masks of arbitrary length. Mask is available thru bits pointer and the mask length is kept in nbits field.MMAP_CPU_MASK_BYTES()macro returns mask storage size in bytes.perf_mmap__print_cpu_mask()function can be used to log text representation of the mask.Signed-off-by Alexey Budankov <[email protected]>--- tools/perf/util/mmap.c | 12 ++++++++++++ tools/perf/util/mmap.h | 11 +++++++++++ 2 files changed, 23 insertions(+)tools/perf/util/mmap.c +0
-0
tools/perf/util/mmap.c line 29
Quoted 7 lines
tools/perf/util/mmap.c +4
-0@@ -23,6 +23,18 @@#include "mmap.h" #include "../perf.h" #include <internal/lib.h> /* page_size */ +#include <linux/bitmap.h> + +#define MASK_SIZE 1023 +void perf_mmap__print_cpu_mask (struct mmap_cpu_mask *mask,const char *tag)
'mmap_cpu_mask__scnprintf' name follows the name logic we try to use
jirka
Quoted 41 lines
tools/perf/util/mmap.c +8
-0+{ +char buf[MASK_SIZE +1 ]; +size_t len; + + len =bitmap_scnprintf (mask->bits, mask->nbits, buf,MASK_SIZE ); + buf[len] ='\0' ; +pr_debug ("%p: %s mask[%ld]: %s\n" , mask, tag, mask->nbits, buf); +}size_t mmap__mmap_len (struct mmap *map) {tools/perf/util/mmap.h +11
-0@@ -15,6 +15,15 @@#include "event.h" struct aiocb ; + +struct mmap_cpu_mask { +unsigned long *bits; +size_t nbits; +}; + +#define MMAP_CPU_MASK_BYTES (m) \ + (BITS_TO_LONGS(((struct mmap_cpu_mask *)m)->nbits) * sizeof(unsigned long)) +/** * struct mmap - perf's ring buffer mmap details * @@ -52,4 +61,6 @@ int perf_mmap__push(struct mmap *md, void *to,size_t mmap__mmap_len (struct mmap *map); +void perf_mmap__print_cpu_mask (struct mmap_cpu_mask *mask,const char *tag); +#endif /*__PERF_MMAP_H */ Signature · 1 line
2.20.1
Re: [PATCH v3 2/3] perf mmap: declare type for cpu mask of arbitrary length
Quoted 14 lines · Jiri Olsa
Quoted 13 lines · Alexey Budankov
Declare a dedicated struct
map_cpu_masktype for cpu masks of arbitrary length. Mask is available thru bits pointer and the mask length is kept in nbits field.MMAP_CPU_MASK_BYTES()macro returns mask storage size in bytes.perf_mmap__print_cpu_mask()function can be used to log text representation of the mask.Signed-off-by Alexey Budankov <[email protected]>--- tools/perf/util/mmap.c | 12 ++++++++++++ tools/perf/util/mmap.h | 11 +++++++++++ 2 files changed, 23 insertions(+)
Quoted 14 lines
tools/perf/util/mmap.c line 29
Quoted 12 lines
tools/perf/util/mmap.c +4
-0@@ -23,6 +23,18 @@#include "mmap.h" #include "../perf.h" #include <internal/lib.h> /* page_size */ +#include <linux/bitmap.h> + +#define MASK_SIZE 1023 +void perf_mmap__print_cpu_mask (struct mmap_cpu_mask *mask,const char *tag)'
mmap_cpu_mask__scnprintf' name follows the name logic we try to use
Renamed in v4.
Thanks,
Alexey
Quoted 46 lines
jirka
Quoted 41 lines
tools/perf/util/mmap.c +8
-0+{ +char buf[MASK_SIZE +1 ]; +size_t len; + + len =bitmap_scnprintf (mask->bits, mask->nbits, buf,MASK_SIZE ); + buf[len] ='\0' ; +pr_debug ("%p: %s mask[%ld]: %s\n" , mask, tag, mask->nbits, buf); +}size_t mmap__mmap_len (struct mmap *map) {tools/perf/util/mmap.h +11
-0@@ -15,6 +15,15 @@#include "event.h" struct aiocb ; + +struct mmap_cpu_mask { +unsigned long *bits; +size_t nbits; +}; + +#define MMAP_CPU_MASK_BYTES (m) \ + (BITS_TO_LONGS(((struct mmap_cpu_mask *)m)->nbits) * sizeof(unsigned long)) +/** * struct mmap - perf's ring buffer mmap details * @@ -52,4 +61,6 @@ int perf_mmap__push(struct mmap *md, void *to,size_t mmap__mmap_len (struct mmap *map); +void perf_mmap__print_cpu_mask (struct mmap_cpu_mask *mask,const char *tag); +#endif /*__PERF_MMAP_H */ Signature · 1 line
2.20.1
PATCH v3 3/3 perf record: adapt affinity to machines with #CPUs > 1K
In reply to Alexey BudankovUse struct mmap_cpu_mask type for tool's thread and mmap data buffers to overcome current 1024 CPUs mask size limitation of cpu_set_t type.
Currently glibc cpu_set_t type has internal mask size limit of 1024 CPUs. Moving to struct mmap_cpu_mask type allows overcoming that limit. tools bitmap API is used to manipulate objects of struct mmap_cpu_mask type.
--- tools/perf/builtin-record.c | 27 +++++++++++++++++++++------ tools/perf/util/mmap.c | 28 ++++++++++++++++++++++------ tools/perf/util/mmap.h | 2 +- 3 files changed, 44 insertions(+), 13 deletions(-)
tools/perf/builtin-record.c +21 -6
@@ -62,6 +62,7 @@#include <linux/string.h> #include <linux/time64.h> #include <linux/zalloc.h> +#include <linux/bitmap.h> struct switch_output {bool enabled;
@@ -93,7 +94,7 @@ struct record {bool timestamp_boundary;struct switch_output switch_output;unsigned long long samples; -cpu_set_t affinity_mask; +struct mmap_cpu_mask affinity_mask;unsigned long output_max_size;/* = 0: unlimited */ };
@@ -961,10 +962,15 @@ static struct perf_event_header finished_round_event = {static void record__adjust_affinity (struct record *rec,struct mmap *map) {if (rec->opts.affinity !=PERF_AFFINITY_SYS && - !CPU_EQUAL (&rec->affinity_mask, &map->affinity_mask)) { -CPU_ZERO (&rec->affinity_mask); -CPU_OR (&rec->affinity_mask, &rec->affinity_mask, &map->affinity_mask); -sched_setaffinity (0 ,sizeof (rec->affinity_mask), &rec->affinity_mask); + !bitmap_equal (rec->affinity_mask.bits, map->affinity_mask.bits, + rec->affinity_mask.nbits)) { +bitmap_zero (rec->affinity_mask.bits, rec->affinity_mask.nbits); +bitmap_or (rec->affinity_mask.bits, rec->affinity_mask.bits, + map->affinity_mask.bits, rec->affinity_mask.nbits); +sched_setaffinity (0 ,MMAP_CPU_MASK_BYTES (&rec->affinity_mask), + (cpu_set_t *)rec->affinity_mask.bits); +if (verbose ==2 ) +perf_mmap__print_cpu_mask (&rec->affinity_mask,"thread" ); } }
@@ -2433,7 +2439,6 @@ int cmd_record(int argc, const char **argv)# undef REASON#endif -CPU_ZERO (&rec->affinity_mask); rec->opts.affinity =PERF_AFFINITY_SYS ; rec->evlist =evlist__new ();
@@ -2499,6 +2504,14 @@ int cmd_record(int argc, const char **argv)symbol__init (NULL ); + rec->affinity_mask.nbits =cpu__max_cpu (); + rec->affinity_mask.bits =bitmap_alloc (rec->affinity_mask.nbits); +if (!rec->affinity_mask.bits) { +pr_err ("Failed to allocate thread mask for %ld cpus\n" , rec->affinity_mask.nbits); +return -ENOMEM ; + } +pr_debug2 ("thread mask[%ld]: empty\n" , rec->affinity_mask.nbits); + err =record__auxtrace_init (rec);if (err) goto out;
@@ -2613,6 +2626,8 @@ int cmd_record(int argc, const char **argv) err =__cmd_record (&record, argc, argv); out: +if (rec->affinity_mask.bits) +bitmap_free (rec->affinity_mask.bits);evlist__delete (rec->evlist);symbol__exit ();auxtrace_record__free (rec->itr);
tools/perf/util/mmap.c +22 -6
@@ -219,6 +219,9 @@ static void perf_mmap__aio_munmap(struct mmap *map __maybe_unused)void mmap__munmap (struct mmap *map) { +if (map->affinity_mask.bits) +bitmap_free (map->affinity_mask.bits); +perf_mmap__aio_munmap (map);if (map->data !=NULL ) {munmap (map->data,mmap__mmap_len (map));
@@ -227,7 +230,7 @@ void mmap__munmap(struct mmap *map)auxtrace_mmap__munmap (&map->auxtrace_mmap); } -static void build_node_mask (int node,cpu_set_t *mask) +static void build_node_mask (int node,struct mmap_cpu_mask *mask) {int c, cpu, nr_cpus;const struct perf_cpu_map *cpu_map =NULL ;
@@ -240,17 +243,23 @@ static void build_node_mask(int node, cpu_set_t *mask)for (c =0 ; c < nr_cpus; c++) { cpu = cpu_map->map[c];/* map c index to online cpu index */ if (cpu__get_node (cpu) == node) -CPU_SET (cpu, mask); +set_bit (cpu, mask->bits); } } -static void perf_mmap__setup_affinity_mask (struct mmap *map,struct mmap_params *mp) +static int perf_mmap__setup_affinity_mask (struct mmap *map,struct mmap_params *mp) { -CPU_ZERO (&map->affinity_mask); + map->affinity_mask.nbits =cpu__max_cpu (); + map->affinity_mask.bits =bitmap_alloc (map->affinity_mask.nbits); +if (!map->affinity_mask.bits) +return -1 ; +if (mp->affinity ==PERF_AFFINITY_NODE &&cpu__max_node () >1 )build_node_mask (cpu__get_node (map->core.cpu), &map->affinity_mask);else if (mp->affinity ==PERF_AFFINITY_CPU ) -CPU_SET (map->core.cpu, &map->affinity_mask); +set_bit (map->core.cpu, map->affinity_mask.bits); + +return 0 ; }int mmap__mmap (struct mmap *map,struct mmap_params *mp,int fd,int cpu)
@@ -261,7 +270,14 @@ int mmap__mmap(struct mmap *map, struct mmap_params *mp, int fd, int cpu)return -1 ; } -perf_mmap__setup_affinity_mask (map, mp); +if (perf_mmap__setup_affinity_mask (map, mp)) { +pr_debug2 ("failed to alloc mmap affinity mask, error %d\n" , + errno); +return -1 ; + } + +if (verbose ==2 ) +perf_mmap__print_cpu_mask (&map->affinity_mask,"mmap" ); map->core.flush = mp->flush;
tools/perf/util/mmap.h +1 -1
@@ -40,7 +40,7 @@ struct mmap { int nr_cblocks; } aio;#endif -cpu_set_t affinity_mask; +struct mmap_cpu_mask affinity_mask;void *data;int comp_level; };
Signature · 1 line
2.20.1
Re: [PATCH v3 3/3] perf record: adapt affinity to machines with #CPUs > 1K
On Fri, Nov 29, 2019 at 01:05:26PM +0300, Alexey Budankov wrote:
SNIP
Quoted 8 lines
# undef REASON #endiftools/perf/builtin-record.c +0
-1-CPU_ZERO (&rec->affinity_mask); rec->opts.affinity =PERF_AFFINITY_SYS ; rec->evlist =evlist__new ();
tools/perf/builtin-record.c int cmd_record(int argc, const char **argv) · line 2513
Quoted 10 lines
tools/perf/builtin-record.c +7
-0@@ -2499,6 +2504,14 @@ int cmd_record(int argc, const char **argv)symbol__init (NULL ); + rec->affinity_mask.nbits =cpu__max_cpu (); + rec->affinity_mask.bits =bitmap_alloc (rec->affinity_mask.nbits); +if (!rec->affinity_mask.bits) { +pr_err ("Failed to allocate thread mask for %ld cpus\n" , rec->affinity_mask.nbits); +return -ENOMEM ; + } +pr_debug2 ("thread mask[%ld]: empty\n" , rec->affinity_mask.nbits);
above can be done only for (rec->opts.affinity != PERF_AFFINITY_SYS)
Quoted 18 lines
tools/perf/builtin-record.c +3
-0+ err =record__auxtrace_init (rec);if (err) goto out;@@ -2613,6 +2626,8 @@ int cmd_record(int argc, const char **argv) err =__cmd_record (&record, argc, argv); out: +if (rec->affinity_mask.bits) +bitmap_free (rec->affinity_mask.bits);evlist__delete (rec->evlist);symbol__exit ();auxtrace_record__free (rec->itr);tools/perf/util/mmap.c +0
-0
tools/perf/util/mmap.c static void perf_mmap__aio_munmap(struct mmap *map __maybe_unused) · line 223
Quoted 5 lines
tools/perf/util/mmap.c +2
-0@@ -219,6 +219,9 @@ static void perf_mmap__aio_munmap(struct mmap *map __maybe_unused)void mmap__munmap (struct mmap *map) { +if (map->affinity_mask.bits) +bitmap_free (map->affinity_mask.bits);
you don't need to check map->affinity_mask.bits, it's checked in free
jirka
Re: [PATCH v3 3/3] perf record: adapt affinity to machines with #CPUs > 1K
Quoted 15 lines · Jiri Olsa
On Fri, Nov 29, 2019 at 01:05:26PM +0300, Alexey Budankov wrote:
SNIP
Quoted 11 lines
# undef REASON #endiftools/perf/builtin-record.c +0
-1-CPU_ZERO (&rec->affinity_mask); rec->opts.affinity =PERF_AFFINITY_SYS ; rec->evlist =evlist__new ();@@ -2499,6 +2504,14 @@ int cmd_record(int argc, const char **argv)symbol__init (NULL );
Quoted 9 lines
tools/perf/builtin-record.c int cmd_record(int argc, const char **argv) · line 2513
Quoted 7 lines
tools/perf/builtin-record.c +7
-0+ rec->affinity_mask.nbits =cpu__max_cpu (); + rec->affinity_mask.bits =bitmap_alloc (rec->affinity_mask.nbits); +if (!rec->affinity_mask.bits) { +pr_err ("Failed to allocate thread mask for %ld cpus\n" , rec->affinity_mask.nbits); +return -ENOMEM ; + } +pr_debug2 ("thread mask[%ld]: empty\n" , rec->affinity_mask.nbits);above can be done only for (
rec->opts.affinity!=PERF_AFFINITY_SYS)
Indeed. Corrected in v4.
Quoted 21 lines
Quoted 21 lines
tools/perf/builtin-record.c +3
-0+ err =record__auxtrace_init (rec);if (err) goto out;@@ -2613,6 +2626,8 @@ int cmd_record(int argc, const char **argv) err =__cmd_record (&record, argc, argv); out: +if (rec->affinity_mask.bits) +bitmap_free (rec->affinity_mask.bits);evlist__delete (rec->evlist);symbol__exit ();auxtrace_record__free (rec->itr);tools/perf/util/mmap.c +0
-0@@ -219,6 +219,9 @@ static void perf_mmap__aio_munmap(struct mmap *map __maybe_unused)
Quoted 6 lines
tools/perf/util/mmap.c static void perf_mmap__aio_munmap(struct mmap *map __maybe_unused) · line 223
Quoted 4 lines
tools/perf/util/mmap.c +2
-0void mmap__munmap (struct mmap *map) { +if (map->affinity_mask.bits) +bitmap_free (map->affinity_mask.bits);you don't need to check
map->affinity_mask.bits, it's checked in free
Makes sense. Corrected in v4.
Quoted 2 lines
jirka
Thanks,
Alexey