Skip to content

Commit

Permalink
removing the non-"numa_" functions from the compatibility wrapper
Browse files Browse the repository at this point in the history 
(per Andi's observation)

They are just internal functions used by the NUMA tools.
They were never designed as a public API, don't have proper numa prefixes,
and will pollute the application's namespace.

Signed-off-by: Cliff Wickman <cpw@sgi.com>
  • Loading branch information
@cpwickman @filbranden
cpwickman authored and filbranden committed Jul 23, 2014
1 parent 99b8f79 commit c085227
Showing 2 changed files with 0 additions and 140 deletions.
128 changes: 0 additions & 128 deletions numa.h
View file
Original file line number Diff line number Diff line change
@@ -253,65 +253,6 @@ struct bitmask *numa_parse_cpustring(char *);
* Such codes should be compiled with VERSION1_COMPATIBILITY defined.
*/

static inline void nodemask_zero_compat(nodemask_t *mask)
{
struct bitmask tmp;

tmp.maskp = (unsigned long *)mask;
tmp.size = sizeof(nodemask_t) * 8;
numa_bitmask_clearall(&tmp);
}

static inline void nodemask_set(struct bitmask *mask, int node)
{
numa_bitmask_setbit(mask, node);
}

static inline void nodemask_set_compat(nodemask_t *mask, int node)
{
struct bitmask tmp;

tmp.maskp = (unsigned long *)mask;
tmp.size = sizeof(nodemask_t) * 8;
numa_bitmask_setbit(&tmp, node);
}

static inline void nodemask_clr(struct bitmask *mask, int node)
{
numa_bitmask_clearbit(mask, node);
}

static inline void nodemask_clr_compat(nodemask_t *mask, int node)
{
mask->n[node / (8*sizeof(unsigned long))] &=
~(1UL<<(node%(8*sizeof(unsigned long))));
}

static inline int nodemask_isset(struct bitmask *mask, int node)
{
return numa_bitmask_isbitset(mask, node);
}

static inline int nodemask_isset_compat(nodemask_t *mask, int node)
{
struct bitmask tmp;

tmp.maskp = (unsigned long *)mask;
tmp.size = sizeof(nodemask_t) * 8;
return numa_bitmask_isbitset(&tmp, node);
}

static inline int nodemask_equal_compat(nodemask_t *a, nodemask_t *b)
{
struct bitmask tmpa, tmpb;

tmpa.maskp = (unsigned long *)a;
tmpa.size = sizeof(nodemask_t) * sizeof(unsigned long);
tmpb.maskp = (unsigned long *)b;
tmpb.size = sizeof(nodemask_t) * sizeof(unsigned long);
return numa_bitmask_equal(&tmpa, &tmpb);
}

static inline void numa_set_interleave_mask_compat(nodemask_t *nodemask)
{
struct bitmask tmp;
@@ -432,27 +373,6 @@ static inline int numa_sched_setaffinity_compat(pid_t pid, unsigned len,
return numa_sched_setaffinity(pid, &tmp);
}

void printcpumask(char *name, struct bitmask *mask);
static inline void printcpumask_compat(char *name, unsigned long *mask,
int size)
{
struct bitmask tmp;

tmp.maskp = (unsigned long *)mask;
tmp.size = size * 8;
printcpumask(name, &tmp);
}

void printmask(char *name, struct bitmask *mask);
static inline void printmask_compat(char *name, nodemask_t *mask)
{
struct bitmask tmp;

tmp.maskp = (unsigned long *)mask;
tmp.size = sizeof(nodemask_t) * 8;
printmask(name, &tmp);
}

static inline int numa_node_to_cpus_compat(int node, unsigned long *buffer,
int buffer_len)
{
@@ -463,54 +383,6 @@ static inline int numa_node_to_cpus_compat(int node, unsigned long *buffer,
return numa_node_to_cpus(node, &tmp);
}

void verify_shm(int policy, struct bitmask *nodes);
static inline void verify_shm_compat(int policy, nodemask_t mask)
{
struct bitmask tmp;

tmp.maskp = (unsigned long *)&mask;
tmp.size = sizeof(nodemask_t) * 8;
verify_shm(policy, &tmp);
}

static inline nodemask_t nodemask_compat(char *c)
{
struct bitmask *tp;
nodemask_t mask;

tp = numa_parse_nodestring(c);
copy_bitmask_to_nodemask(tp, &mask);
numa_bitmask_free(tp);
return mask;
}

static inline unsigned long *cpumask_compat(char *c, int *ncpus)
{
struct bitmask *tp;
unsigned long *cpubuf;

tp = numa_parse_cpustring(c);
*ncpus = tp->size;
cpubuf = calloc(tp->size,1);
if (!cpubuf) {
numa_error("Out of memory");
return NULL;
}
memcpy(cpubuf, tp->maskp, tp->size/8);
numa_bitmask_free(tp);
return cpubuf;
}

#include <stdio.h>
static inline int test_bit_compat(int bit, unsigned long *mask)
{
struct bitmask tmp;

tmp.maskp = mask;
tmp.size = sizeof(nodemask_t) * 8;
return numa_bitmask_isbitset(&tmp, bit);
}

/* end of version 1 compatibility functions */

/*
12 changes: 0 additions & 12 deletions numacompat1.h
View file
Original file line number Diff line number Diff line change
@@ -1,9 +1,4 @@
#define nodemask_clr(m,n) nodemask_clr_compat(m,n)
#define nodemask_isset(m,n) nodemask_isset_compat(m,n)
#define nodemask_equal(m,n) nodemask_equal_compat(m,n)
#define numa_set_interleave_mask(m) numa_set_interleave_mask_compat(m)
#define nodemask_set(m,n) nodemask_set_compat(m,n)
#define nodemask_zero(m) nodemask_zero_compat(m)
#define numa_get_interleave_mask() numa_get_interleave_mask_compat()
#define numa_bind(m) numa_bind_compat(m)
#define numa_get_membind(m) numa_get_membind_compat(m)
@@ -15,11 +10,4 @@
#define numa_tonodemask_memory(st,si,m) numa_tonodemask_memory_compat(st,si,m)
#define numa_sched_getaffinity(p,l,m) numa_sched_getaffinity_compat(p,l,m)
#define numa_sched_setaffinity(p,l,m) numa_sched_setaffinity_compat(p,l,m)
#define printcpumask(n,m,s) printcpumask_compat(n,m,s)
#define printmask(n,m) printmask_compat(n,m)
#define numa_node_to_cpus(n,b,bl) numa_node_to_cpus_compat(n,b,bl)
#define verify_shm(p,m) verify_shm_compat(p,m)
#define nodemask(c) nodemask_compat(c)
#define cpumask(c,n) cpumask_compat(c,n)
#undef test_bit
#define test_bit(i,p) test_bit_compat(i,p)

0 comments on commit c085227

Please sign in to comment.