arch/ia64/kernel/domain.c

   1 /*
   2  * arch/ia64/kernel/domain.c
   3  * Architecture specific sched-domains builder.
   4  *
   5  * Copyright (C) 2004 Jesse Barnes
   6  * Copyright (C) 2004 Silicon Graphics, Inc.
   7  */
   8
   9 #include <linux/sched.h>
  10 #include <linux/percpu.h>
  11 #include <linux/slab.h>
  12 #include <linux/cpumask.h>
  13 #include <linux/init.h>
  14 #include <linux/topology.h>
  15 #include <linux/nodemask.h>
  16
  17 #define SD_NODES_PER_DOMAIN 16
  18
  19 #ifdef CONFIG_NUMA
  20 /**
  21  * find_next_best_node - find the next node to include in a sched_domain
  22  * @node: node whose sched_domain we're building
  23  * @used_nodes: nodes already in the sched_domain
  24  *
  25  * Find the next node to include in a given scheduling domain.  Simply
  26  * finds the closest node not already in the @used_nodes map.
  27  *
  28  * Should use nodemask_t.
  29  */
  30 static int find_next_best_node(int node, unsigned long *used_nodes)
  31 {
  32         int i, n, val, min_val, best_node = 0;
  33
  34         min_val = INT_MAX;
  35
  36         for (i = 0; i < MAX_NUMNODES; i++) {
  37                 /* Start at @node */
  38                 n = (node + i) % MAX_NUMNODES;
  39
  40                 if (!nr_cpus_node(n))
  41                         continue;
  42
  43                 /* Skip already used nodes */
  44                 if (test_bit(n, used_nodes))
  45                         continue;
  46
  47                 /* Simple min distance search */
  48                 val = node_distance(node, n);
  49
  50                 if (val < min_val) {
  51                         min_val = val;
  52                         best_node = n;
  53                 }
  54         }
  55
  56         set_bit(best_node, used_nodes);
  57         return best_node;
  58 }
  59
  60 /**
  61  * sched_domain_node_span - get a cpumask for a node's sched_domain
  62  * @node: node whose cpumask we're constructing
  63  * @size: number of nodes to include in this span
  64  *
  65  * Given a node, construct a good cpumask for its sched_domain to span.  It
  66  * should be one that prevents unnecessary balancing, but also spreads tasks
  67  * out optimally.
  68  */
  69 static cpumask_t sched_domain_node_span(int node)
  70 {
  71         int i;
  72         cpumask_t span, nodemask;
  73         DECLARE_BITMAP(used_nodes, MAX_NUMNODES);
  74
  75         cpus_clear(span);
  76         bitmap_zero(used_nodes, MAX_NUMNODES);
  77
  78         nodemask = node_to_cpumask(node);
  79         cpus_or(span, span, nodemask);
  80         set_bit(node, used_nodes);
  81
  82         for (i = 1; i < SD_NODES_PER_DOMAIN; i++) {
  83                 int next_node = find_next_best_node(node, used_nodes);
  84                 nodemask = node_to_cpumask(next_node);
  85                 cpus_or(span, span, nodemask);
  86         }
  87
  88         return span;
  89 }
  90 #endif
  91
  92 /*
  93  * At the moment, CONFIG_SCHED_SMT is never defined, but leave it in so we
  94  * can switch it on easily if needed.
  95  */
  96 #ifdef CONFIG_SCHED_SMT
  97 static DEFINE_PER_CPU(struct sched_domain, cpu_domains);
  98 static struct sched_group sched_group_cpus[NR_CPUS];
  99 static int cpu_to_cpu_group(int cpu)
 100 {
 101         return cpu;
 102 }
 103 #endif
 104
 105 static DEFINE_PER_CPU(struct sched_domain, phys_domains);
 106 static struct sched_group sched_group_phys[NR_CPUS];
 107 static int cpu_to_phys_group(int cpu)
 108 {
 109 #ifdef CONFIG_SCHED_SMT
 110         return first_cpu(cpu_sibling_map[cpu]);
 111 #else
 112         return cpu;
 113 #endif
 114 }
 115
 116 #ifdef CONFIG_NUMA
 117 /*
 118  * The init_sched_build_groups can't handle what we want to do with node
 119  * groups, so roll our own. Now each node has its own list of groups which
 120  * gets dynamically allocated.
 121  */
 122 static DEFINE_PER_CPU(struct sched_domain, node_domains);
 123 static struct sched_group *sched_group_nodes[MAX_NUMNODES];
 124
 125 static DEFINE_PER_CPU(struct sched_domain, allnodes_domains);
 126 static struct sched_group sched_group_allnodes[MAX_NUMNODES];
 127
 128 static int cpu_to_allnodes_group(int cpu)
 129 {
 130         return cpu_to_node(cpu);
 131 }
 132 #endif
 133
 134 /*
 135  * Build sched domains for a given set of cpus and attach the sched domains
 136  * to the individual cpus
 137  */
 138 void build_sched_domains(const cpumask_t *cpu_map)
 139 {
 140         int i;
 141
 142         /*
 143          * Set up domains for cpus specified by the cpu_map.
 144          */
 145         for_each_cpu_mask(i, *cpu_map) {
 146                 int group;
 147                 struct sched_domain *sd = NULL, *p;
 148                 cpumask_t nodemask = node_to_cpumask(cpu_to_node(i));
 149
 150                 cpus_and(nodemask, nodemask, *cpu_map);
 151
 152 #ifdef CONFIG_NUMA
 153                 if (num_online_cpus()
 154                                 > SD_NODES_PER_DOMAIN*cpus_weight(nodemask)) {
 155                         sd = &per_cpu(allnodes_domains, i);
 156                         *sd = SD_ALLNODES_INIT;
 157                         sd->span = *cpu_map;
 158                         group = cpu_to_allnodes_group(i);
 159                         sd->groups = &sched_group_allnodes[group];
 160                         p = sd;
 161                 } else
 162                         p = NULL;
 163
 164                 sd = &per_cpu(node_domains, i);
 165                 *sd = SD_NODE_INIT;
 166                 sd->span = sched_domain_node_span(cpu_to_node(i));
 167                 sd->parent = p;
 168                 cpus_and(sd->span, sd->span, *cpu_map);
 169 #endif
 170
 171                 p = sd;
 172                 sd = &per_cpu(phys_domains, i);
 173                 group = cpu_to_phys_group(i);
 174                 *sd = SD_CPU_INIT;
 175                 sd->span = nodemask;
 176                 sd->parent = p;
 177                 sd->groups = &sched_group_phys[group];
 178
 179 #ifdef CONFIG_SCHED_SMT
 180                 p = sd;
 181                 sd = &per_cpu(cpu_domains, i);
 182                 group = cpu_to_cpu_group(i);
 183                 *sd = SD_SIBLING_INIT;
 184                 sd->span = cpu_sibling_map[i];
 185                 cpus_and(sd->span, sd->span, *cpu_map);
 186                 sd->parent = p;
 187                 sd->groups = &sched_group_cpus[group];
 188 #endif
 189         }
 190
 191 #ifdef CONFIG_SCHED_SMT
 192         /* Set up CPU (sibling) groups */
 193         for_each_cpu_mask(i, *cpu_map) {
 194                 cpumask_t this_sibling_map = cpu_sibling_map[i];
 195                 cpus_and(this_sibling_map, this_sibling_map, *cpu_map);
 196                 if (i != first_cpu(this_sibling_map))
 197                         continue;
 198
 199                 init_sched_build_groups(sched_group_cpus, this_sibling_map,
 200                                                 &cpu_to_cpu_group);
 201         }
 202 #endif
 203
 204         /* Set up physical groups */
 205         for (i = 0; i < MAX_NUMNODES; i++) {
 206                 cpumask_t nodemask = node_to_cpumask(i);
 207
 208                 cpus_and(nodemask, nodemask, *cpu_map);
 209                 if (cpus_empty(nodemask))
 210                         continue;
 211
 212                 init_sched_build_groups(sched_group_phys, nodemask,
 213                                                 &cpu_to_phys_group);
 214         }
 215
 216 #ifdef CONFIG_NUMA
 217         init_sched_build_groups(sched_group_allnodes, *cpu_map,
 218                                 &cpu_to_allnodes_group);
 219
 220         for (i = 0; i < MAX_NUMNODES; i++) {
 221                 /* Set up node groups */
 222                 struct sched_group *sg, *prev;
 223                 cpumask_t nodemask = node_to_cpumask(i);
 224                 cpumask_t domainspan;
 225                 cpumask_t covered = CPU_MASK_NONE;
 226                 int j;
 227
 228                 cpus_and(nodemask, nodemask, *cpu_map);
 229                 if (cpus_empty(nodemask))
 230                         continue;
 231
 232                 domainspan = sched_domain_node_span(i);
 233                 cpus_and(domainspan, domainspan, *cpu_map);
 234
 235                 sg = kmalloc(sizeof(struct sched_group), GFP_KERNEL);
 236                 sched_group_nodes[i] = sg;
 237                 for_each_cpu_mask(j, nodemask) {
 238                         struct sched_domain *sd;
 239                         sd = &per_cpu(node_domains, j);
 240                         sd->groups = sg;
 241                         if (sd->groups == NULL) {
 242                                 /* Turn off balancing if we have no groups */
 243                                 sd->flags = 0;
 244                         }
 245                 }
 246                 if (!sg) {
 247                         printk(KERN_WARNING
 248                         "Can not alloc domain group for node %d\n", i);
 249                         continue;
 250                 }
 251                 sg->cpu_power = 0;
 252                 sg->cpumask = nodemask;
 253                 cpus_or(covered, covered, nodemask);
 254                 prev = sg;
 255
 256                 for (j = 0; j < MAX_NUMNODES; j++) {
 257                         cpumask_t tmp, notcovered;
 258                         int n = (i + j) % MAX_NUMNODES;
 259
 260                         cpus_complement(notcovered, covered);
 261                         cpus_and(tmp, notcovered, *cpu_map);
 262                         cpus_and(tmp, tmp, domainspan);
 263                         if (cpus_empty(tmp))
 264                                 break;
 265
 266                         nodemask = node_to_cpumask(n);
 267                         cpus_and(tmp, tmp, nodemask);
 268                         if (cpus_empty(tmp))
 269                                 continue;
 270
 271                         sg = kmalloc(sizeof(struct sched_group), GFP_KERNEL);
 272                         if (!sg) {
 273                                 printk(KERN_WARNING
 274                                 "Can not alloc domain group for node %d\n", j);
 275                                 break;
 276                         }
 277                         sg->cpu_power = 0;
 278                         sg->cpumask = tmp;
 279                         cpus_or(covered, covered, tmp);
 280                         prev->next = sg;
 281                         prev = sg;
 282                 }
 283                 prev->next = sched_group_nodes[i];
 284         }
 285 #endif
 286
 287         /* Calculate CPU power for physical packages and nodes */
 288         for_each_cpu_mask(i, *cpu_map) {
 289                 int power;
 290                 struct sched_domain *sd;
 291 #ifdef CONFIG_SCHED_SMT
 292                 sd = &per_cpu(cpu_domains, i);
 293                 power = SCHED_LOAD_SCALE;
 294                 sd->groups->cpu_power = power;
 295 #endif
 296
 297                 sd = &per_cpu(phys_domains, i);
 298                 power = SCHED_LOAD_SCALE + SCHED_LOAD_SCALE *
 299                                 (cpus_weight(sd->groups->cpumask)-1) / 10;
 300                 sd->groups->cpu_power = power;
 301
 302 #ifdef CONFIG_NUMA
 303                 sd = &per_cpu(allnodes_domains, i);
 304                 if (sd->groups) {
 305                         power = SCHED_LOAD_SCALE + SCHED_LOAD_SCALE *
 306                                 (cpus_weight(sd->groups->cpumask)-1) / 10;
 307                         sd->groups->cpu_power = power;
 308                 }
 309 #endif
 310         }
 311
 312 #ifdef CONFIG_NUMA
 313         for (i = 0; i < MAX_NUMNODES; i++) {
 314                 struct sched_group *sg = sched_group_nodes[i];
 315                 int j;
 316
 317                 if (sg == NULL)
 318                         continue;
 319 next_sg:
 320                 for_each_cpu_mask(j, sg->cpumask) {
 321                         struct sched_domain *sd;
 322                         int power;
 323
 324                         sd = &per_cpu(phys_domains, j);
 325                         if (j != first_cpu(sd->groups->cpumask)) {
 326                                 /*
 327                                  * Only add "power" once for each
 328                                  * physical package.
 329                                  */
 330                                 continue;
 331                         }
 332                         power = SCHED_LOAD_SCALE + SCHED_LOAD_SCALE *
 333                                 (cpus_weight(sd->groups->cpumask)-1) / 10;
 334
 335                         sg->cpu_power += power;
 336                 }
 337                 sg = sg->next;
 338                 if (sg != sched_group_nodes[i])
 339                         goto next_sg;
 340         }
 341 #endif
 342
 343         /* Attach the domains */
 344         for_each_online_cpu(i) {
 345                 struct sched_domain *sd;
 346 #ifdef CONFIG_SCHED_SMT
 347                 sd = &per_cpu(cpu_domains, i);
 348 #else
 349                 sd = &per_cpu(phys_domains, i);
 350 #endif
 351                 cpu_attach_domain(sd, i);
 352         }
 353 }
 354 /*
 355  * Set up scheduler domains and groups.  Callers must hold the hotplug lock.
 356  */
 357 void arch_init_sched_domains(const cpumask_t *cpu_map)
 358 {
 359         cpumask_t cpu_default_map;
 360
 361         /*
 362          * Setup mask for cpus without special case scheduling requirements.
 363          * For now this just excludes isolated cpus, but could be used to
 364          * exclude other special cases in the future.
 365          */
 366         cpus_andnot(cpu_default_map, *cpu_map, cpu_isolated_map);
 367
 368         build_sched_domains(&cpu_default_map);
 369 }
 370
 371 void arch_destroy_sched_domains(const cpumask_t *cpu_map)
 372 {
 373 #ifdef CONFIG_NUMA
 374         int i;
 375         for (i = 0; i < MAX_NUMNODES; i++) {
 376                 cpumask_t nodemask = node_to_cpumask(i);
 377                 struct sched_group *oldsg, *sg = sched_group_nodes[i];
 378
 379                 cpus_and(nodemask, nodemask, *cpu_map);
 380                 if (cpus_empty(nodemask))
 381                         continue;
 382
 383                 if (sg == NULL)
 384                         continue;
 385                 sg = sg->next;
 386 next_sg:
 387                 oldsg = sg;
 388                 sg = sg->next;
 389                 kfree(oldsg);
 390                 if (oldsg != sched_group_nodes[i])
 391                         goto next_sg;
 392                 sched_group_nodes[i] = NULL;
 393         }
 394 #endif
 395 }
 396