Change all references of num_cpus -> num_cores
authorKevin Klues <klueska@cs.berkeley.edu>
Tue, 21 Jul 2015 03:10:13 +0000 (20:10 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Thu, 23 Jul 2015 08:22:27 +0000 (04:22 -0400)
As we start to integrate more sophisticated cputopology information into
the kernel, we will need to be careful about our naming of these
variables.  CPUs are different than cores (on a hyperthreaded machine,
there are at least 2 cores per cpu), so we need to be more consistent
with our naming to avoid confusion.  Moreover, as we add more
cputopology information, we will likey want to know the actual num_cpus
in addition to the num_cores, so we want to make sure we have the right
semantics for these variables before this change is introduced.

36 files changed:
kern/arch/riscv/boot.S
kern/arch/riscv/cboot.c
kern/arch/riscv/riscv.h
kern/arch/riscv/ros/arch.h
kern/arch/riscv/smp.c
kern/arch/riscv/smp.h
kern/arch/riscv/trap.c
kern/arch/x86/coreid.h
kern/arch/x86/entry64.S
kern/arch/x86/ros/arch.h
kern/arch/x86/smp.c
kern/arch/x86/smp_boot.c
kern/arch/x86/smp_entry64.S
kern/arch/x86/trap.c
kern/arch/x86/vmm/vmm.c
kern/arch/x86/x86.h
kern/drivers/dev/acpi.c
kern/drivers/dev/kprof.c
kern/drivers/dev/nix.c
kern/drivers/net/bnx2x/bnx2x_cmn.c
kern/include/atomic.h
kern/include/ros/procdata.h
kern/include/ros/procinfo.h
kern/include/smp.h
kern/src/alarm.c
kern/src/event.c
kern/src/frontend.c
kern/src/ktest/pb_ktests.c
kern/src/manager.c
kern/src/monitor.c
kern/src/oprofile/cpu_buffer.c
kern/src/process.c
kern/src/schedule.c
kern/src/smp.c
kern/src/trap.c
tools/jenkins/config/Makelocal_qemu

index 6fbe805..b6354f4 100644 (file)
@@ -69,12 +69,12 @@ _start:
 
 notcore0:
   // wait for core 0 to boot
 
 notcore0:
   // wait for core 0 to boot
-  la     a8, num_cpus_booted - KERN_LOAD_ADDR
+  la     a8, num_cores_booted - KERN_LOAD_ADDR
 1:lw     a9, 0(a8)
   beqz   a9, 1b
 
 1:lw     a9, 0(a8)
   beqz   a9, 1b
 
-  // if for some reason coreid >= num_cpus, don't boot this core
-  la     a8, num_cpus - KERN_LOAD_ADDR
+  // if for some reason coreid >= num_cores, don't boot this core
+  la     a8, num_cores - KERN_LOAD_ADDR
   lw     a8, 0(a8)
 1:bgeu   a6, a8, 1b
 
   lw     a8, 0(a8)
 1:bgeu   a6, a8, 1b
 
@@ -120,4 +120,4 @@ l2pt:
 
   .global percore_stacks
 percore_stacks:
 
   .global percore_stacks
 percore_stacks:
-  .space  KSTKSIZE*MAX_NUM_CPUS
+  .space  KSTKSIZE*MAX_NUM_CORES
index 952677c..6161de5 100644 (file)
@@ -9,7 +9,7 @@
 
 #define MAX_KERNBASE_SIZE (KERN_VMAP_TOP - KERNBASE)
 
 
 #define MAX_KERNBASE_SIZE (KERN_VMAP_TOP - KERNBASE)
 
-uint32_t num_cpus = 1;   // this must not be in BSS
+uint32_t num_cores = 1;   // this must not be in BSS
 
 static uint64_t
 mem_size(uint64_t sz_mb)
 
 static uint64_t
 mem_size(uint64_t sz_mb)
@@ -55,14 +55,14 @@ void pagetable_init(uint32_t memsize_mb, pte_t* l1pt, pte_t* l1pt_boot,
 }
 
 void
 }
 
 void
-cmain(uint32_t memsize_mb, uint32_t num_cores)
+cmain(uint32_t memsize_mb, uint32_t nc)
 {
        multiboot_info_t mbi;
        memset(&mbi, 0, sizeof(mbi));
        mbi.flags = 0x00000001;
        mbi.mem_lower = mem_size(memsize_mb) / 1024;
 
 {
        multiboot_info_t mbi;
        memset(&mbi, 0, sizeof(mbi));
        mbi.flags = 0x00000001;
        mbi.mem_lower = mem_size(memsize_mb) / 1024;
 
-       num_cpus = num_cores;
+       num_cores = nc;
 
        extern void kernel_init(multiboot_info_t *mboot_info);
        // kernel_init expects a pre-relocation mbi address
 
        extern void kernel_init(multiboot_info_t *mboot_info);
        // kernel_init expects a pre-relocation mbi address
index 9bdb660..484bf5e 100644 (file)
@@ -41,8 +41,8 @@ static __inline void
 send_broadcast_ipi(uint8_t vector)
 {
 #warning "broadcast ipi?"
 send_broadcast_ipi(uint8_t vector)
 {
 #warning "broadcast ipi?"
-       /* num_cpus might not be visible here */
-       for (int i = 0; i < num_cpus; i++)
+       /* num_cores might not be visible here */
+       for (int i = 0; i < num_cores; i++)
                send_ipi(i, vector);
 }
 
                send_ipi(i, vector);
 }
 
index a193e62..2e8c17a 100644 (file)
@@ -1,7 +1,7 @@
 #ifndef _ROS_ARCH_ARCH_H
 #define _ROS_ARCH_ARCH_H
 
 #ifndef _ROS_ARCH_ARCH_H
 #define _ROS_ARCH_ARCH_H
 
-#define MAX_NUM_CPUS                           16 // it's safe to change this as needed
+#define MAX_NUM_CORES                          16 // it's safe to change this as needed
 
 #ifndef __ASSEMBLER__
 
 
 #ifndef __ASSEMBLER__
 
index 89d3a10..d064c64 100644 (file)
@@ -8,15 +8,15 @@
 #include <atomic.h>
 #include <pmap.h>
 
 #include <atomic.h>
 #include <pmap.h>
 
-volatile uint32_t num_cpus_booted = 0;
+volatile uint32_t num_cores_booted = 0;
 
 void
 smp_boot(void)
 {
        smp_percpu_init();
 
 void
 smp_boot(void)
 {
        smp_percpu_init();
-       num_cpus_booted = 1;
-       while(num_cpus_booted < num_cpus);
-       printd("%d cores reporting!\n", num_cpus);
+       num_cores_booted = 1;
+       while(num_cores_booted < num_cores);
+       printd("%d cores reporting!\n", num_cores);
 }
 
 void
 }
 
 void
@@ -24,7 +24,7 @@ smp_init(void)
 {
        smp_percpu_init();
 
 {
        smp_percpu_init();
 
-       __sync_fetch_and_add(&num_cpus_booted, 1);
+       __sync_fetch_and_add(&num_cores_booted, 1);
        printd("Good morning, Vietnam! (core id = %d)\n",core_id());
 
        smp_idle();
        printd("Good morning, Vietnam! (core id = %d)\n",core_id());
 
        smp_idle();
@@ -34,7 +34,7 @@ handler_wrapper_t*
 smp_make_wrapper()
 {
        static handler_wrapper_t
 smp_make_wrapper()
 {
        static handler_wrapper_t
-       wrapper_pool[MAX_NUM_CPUS*8] = {{{0},SPINLOCK_INITIALIZER}};
+       wrapper_pool[MAX_NUM_CORES*8] = {{{0},SPINLOCK_INITIALIZER}};
 
        size_t i;
        for(i = 0; i < sizeof(wrapper_pool)/sizeof(wrapper_pool[0]); i++)
 
        size_t i;
        for(i = 0; i < sizeof(wrapper_pool)/sizeof(wrapper_pool[0]); i++)
@@ -69,14 +69,14 @@ int smp_call_function_all(isr_t handler, void* data,
                if(!wrapper)
                        return -ENOMEM;
 
                if(!wrapper)
                        return -ENOMEM;
 
-               for(i = 0; i < num_cpus; i++)
+               for(i = 0; i < num_cores; i++)
                        wrapper->wait_list[i] = 1;
        }
 
        enable_irqsave(&state);
 
        // send to others
                        wrapper->wait_list[i] = 1;
        }
 
        enable_irqsave(&state);
 
        // send to others
-       for(i = 0, me = core_id(); i < num_cpus; i++)
+       for(i = 0, me = core_id(); i < num_cores; i++)
        {
                if(i == me)
                        continue;
        {
                if(i == me)
                        continue;
@@ -124,7 +124,7 @@ int smp_call_function_single(uint32_t dest, isr_t handler, void* data,
 int smp_call_wait(handler_wrapper_t* wrapper)
 {
        int i;
 int smp_call_wait(handler_wrapper_t* wrapper)
 {
        int i;
-       for(i = 0; i < num_cpus; i++)
+       for(i = 0; i < num_cores; i++)
                while(wrapper->wait_list[i]);
 
        spin_unlock(&wrapper->lock);
                while(wrapper->wait_list[i]);
 
        spin_unlock(&wrapper->lock);
index b71f0de..08e21bb 100644 (file)
@@ -5,7 +5,7 @@
 #include <arch/arch.h>
 #include <atomic.h>
 
 #include <arch/arch.h>
 #include <atomic.h>
 
-typedef volatile uint8_t wait_list_t[MAX_NUM_CPUS];
+typedef volatile uint8_t wait_list_t[MAX_NUM_CORES];
 
 typedef struct
 {
 
 typedef struct
 {
index 1d9055d..9a115eb 100644 (file)
@@ -24,7 +24,7 @@
  *
  * TODO: if these end up becoming contended cache lines, move this to
  * per_cpu_info. */
  *
  * TODO: if these end up becoming contended cache lines, move this to
  * per_cpu_info. */
-uintptr_t core_stacktops[MAX_NUM_CPUS] = {0xcafebabe, 0};
+uintptr_t core_stacktops[MAX_NUM_CORES] = {0xcafebabe, 0};
 
 void
 advance_pc(struct hw_trapframe *state)
 
 void
 advance_pc(struct hw_trapframe *state)
index 5043ef4..71923c3 100644 (file)
@@ -12,8 +12,8 @@ static inline int node_id(void) __attribute__((always_inline));
 static inline int core_id_early(void) __attribute__((always_inline));
 
 /* declared in smp.c */
 static inline int core_id_early(void) __attribute__((always_inline));
 
 /* declared in smp.c */
-extern int hw_coreid_lookup[MAX_NUM_CPUS];
-extern int os_coreid_lookup[MAX_NUM_CPUS];
+extern int hw_coreid_lookup[MAX_NUM_CORES];
+extern int os_coreid_lookup[MAX_NUM_CORES];
 
 /* os_coreid -> hw_coreid */
 static inline int get_hw_coreid(uint32_t coreid)
 
 /* os_coreid -> hw_coreid */
 static inline int get_hw_coreid(uint32_t coreid)
index 2328aa8..e662f89 100644 (file)
@@ -400,7 +400,7 @@ long_mode:
        # Clear the frame pointer for proper backtraces
        movq    $0x0, %rbp
        movabs  $(bootstacktop), %rsp
        # Clear the frame pointer for proper backtraces
        movq    $0x0, %rbp
        movabs  $(bootstacktop), %rsp
-       movabs  $(num_cpus), %rax
+       movabs  $(num_cores), %rax
        movl    $0x1, (%rax)
        # Pass multiboot info to kernel_init (%rdi == arg1)
        movq    %rbx, %rdi
        movl    $0x1, (%rax)
        # Pass multiboot info to kernel_init (%rdi == arg1)
        movq    %rbx, %rdi
index 73e7e5d..a7d25d8 100644 (file)
@@ -1,6 +1,6 @@
 #ifndef _ROS_ARCH_ARCH_H
 #define _ROS_ARCH_ARCH_H
 
 #ifndef _ROS_ARCH_ARCH_H
 #define _ROS_ARCH_ARCH_H
 
-#define MAX_NUM_CPUS                           255
+#define MAX_NUM_CORES                          255
 
 #endif
 
 #endif
index 863e4d3..55e2817 100644 (file)
@@ -18,8 +18,8 @@
 #include <trap.h>
 
 /* Lookup table for core_id and per_cpu_inf, indexed by real __core_id() */
 #include <trap.h>
 
 /* Lookup table for core_id and per_cpu_inf, indexed by real __core_id() */
-int hw_coreid_lookup[MAX_NUM_CPUS] = {[0 ... (MAX_NUM_CPUS - 1)] -1};
-int os_coreid_lookup[MAX_NUM_CPUS] = {[0 ... (MAX_NUM_CPUS - 1)] -1};
+int hw_coreid_lookup[MAX_NUM_CORES] = {[0 ... (MAX_NUM_CORES - 1)] -1};
+int os_coreid_lookup[MAX_NUM_CORES] = {[0 ... (MAX_NUM_CORES - 1)] -1};
 
 /*************************** IPI Wrapper Stuff ********************************/
 // checklists to protect the global interrupt_handlers for 0xf0, f1, f2, f3, f4
 
 /*************************** IPI Wrapper Stuff ********************************/
 // checklists to protect the global interrupt_handlers for 0xf0, f1, f2, f3, f4
@@ -44,22 +44,22 @@ static int smp_call_function(uint8_t type, uint32_t dest, isr_t handler,
        }
 
        // assumes our cores are numbered in order
        }
 
        // assumes our cores are numbered in order
-       if ((type == 4) && (dest >= num_cpus))
+       if ((type == 4) && (dest >= num_cores))
                panic("Destination CPU %d does not exist!", dest);
 
        // build the mask based on the type and destination
                panic("Destination CPU %d does not exist!", dest);
 
        // build the mask based on the type and destination
-       INIT_CHECKLIST_MASK(cpu_mask, MAX_NUM_CPUS);
+       INIT_CHECKLIST_MASK(cpu_mask, MAX_NUM_CORES);
        // set checklist mask's size dynamically to the num cpus actually present
        // set checklist mask's size dynamically to the num cpus actually present
-       cpu_mask.size = num_cpus;
+       cpu_mask.size = num_cores;
        switch (type) {
                case 1: // self
                        SET_BITMASK_BIT(cpu_mask.bits, core_id());
                        break;
                case 2: // all
        switch (type) {
                case 1: // self
                        SET_BITMASK_BIT(cpu_mask.bits, core_id());
                        break;
                case 2: // all
-                       FILL_BITMASK(cpu_mask.bits, num_cpus);
+                       FILL_BITMASK(cpu_mask.bits, num_cores);
                        break;
                case 3: // all but self
                        break;
                case 3: // all but self
-                       FILL_BITMASK(cpu_mask.bits, num_cpus);
+                       FILL_BITMASK(cpu_mask.bits, num_cores);
                        CLR_BITMASK_BIT(cpu_mask.bits, core_id());
                        break;
                case 4: // physical mode
                        CLR_BITMASK_BIT(cpu_mask.bits, core_id());
                        break;
                case 4: // physical mode
index 96bdba6..8a20063 100644 (file)
 #include "vmm/vmm.h"
 
 extern handler_wrapper_t handler_wrappers[NUM_HANDLER_WRAPPERS];
 #include "vmm/vmm.h"
 
 extern handler_wrapper_t handler_wrappers[NUM_HANDLER_WRAPPERS];
-volatile uint32_t num_cpus = 0xee;
+volatile uint32_t num_cores = 0xee;
 uintptr_t smp_stack_top;
 barrier_t generic_barrier;
 
 #define DECLARE_HANDLER_CHECKLISTS(vector)                          \
 uintptr_t smp_stack_top;
 barrier_t generic_barrier;
 
 #define DECLARE_HANDLER_CHECKLISTS(vector)                          \
-       INIT_CHECKLIST(f##vector##_cpu_list, MAX_NUM_CPUS);
+       INIT_CHECKLIST(f##vector##_cpu_list, MAX_NUM_CORES);
 
 #define INIT_HANDLER_WRAPPER(v)                                     \
 {                                                                   \
        handler_wrappers[(v)].vector = 0xe##v;                          \
        handler_wrappers[(v)].cpu_list = &f##v##_cpu_list;              \
 
 #define INIT_HANDLER_WRAPPER(v)                                     \
 {                                                                   \
        handler_wrappers[(v)].vector = 0xe##v;                          \
        handler_wrappers[(v)].cpu_list = &f##v##_cpu_list;              \
-       handler_wrappers[(v)].cpu_list->mask.size = num_cpus;           \
+       handler_wrappers[(v)].cpu_list->mask.size = num_cores;          \
 }
 
 DECLARE_HANDLER_CHECKLISTS(0);
 }
 
 DECLARE_HANDLER_CHECKLISTS(0);
@@ -139,12 +139,12 @@ static void __spin_bootlock_raw(void)
  * in hw_coreid_lookup, jumping over gaps of -1's. */
 static void smp_remap_coreids(void)
 {
  * in hw_coreid_lookup, jumping over gaps of -1's. */
 static void smp_remap_coreids(void)
 {
-       for (int i = 0, hw_step = 0; i < num_cpus; i++, hw_step++) {
+       for (int i = 0, hw_step = 0; i < num_cores; i++, hw_step++) {
                if (hw_coreid_lookup[i] == -1) {
                        while (hw_coreid_lookup[hw_step] == -1) {
                                hw_step++;
                if (hw_coreid_lookup[i] == -1) {
                        while (hw_coreid_lookup[hw_step] == -1) {
                                hw_step++;
-                               if (hw_step == MAX_NUM_CPUS)
-                                       panic("Mismatch in num_cpus and hw_step");
+                               if (hw_step == MAX_NUM_CORES)
+                                       panic("Mismatch in num_cores and hw_step");
                        }
                        hw_coreid_lookup[i] = hw_coreid_lookup[hw_step];
                        hw_coreid_lookup[hw_step] = -1;
                        }
                        hw_coreid_lookup[i] = hw_coreid_lookup[hw_step];
                        hw_coreid_lookup[hw_step] = -1;
@@ -210,10 +210,10 @@ void smp_boot(void)
        // mapping pulled out from under them.  Now, if a core loses, it will spin
        // on the trampoline (which we must be careful to not deallocate)
        __spin_bootlock_raw();
        // mapping pulled out from under them.  Now, if a core loses, it will spin
        // on the trampoline (which we must be careful to not deallocate)
        __spin_bootlock_raw();
-       printk("Number of Cores Detected: %d\n", num_cpus);
+       printk("Number of Cores Detected: %d\n", num_cores);
 #ifdef CONFIG_DISABLE_SMT
 #ifdef CONFIG_DISABLE_SMT
-       assert(!(num_cpus % 2));
-       printk("Using only %d Idlecores (SMT Disabled)\n", num_cpus >> 1);
+       assert(!(num_cores % 2));
+       printk("Using only %d Idlecores (SMT Disabled)\n", num_cores >> 1);
 #endif /* CONFIG_DISABLE_SMT */
        smp_remap_coreids();
 
 #endif /* CONFIG_DISABLE_SMT */
        smp_remap_coreids();
 
@@ -222,7 +222,7 @@ void smp_boot(void)
        // It had a refcount of 2 earlier, so we need to dec once more to free it
        // but only if all cores are in (or we reset / reinit those that failed)
        // TODO after we parse ACPI tables
        // It had a refcount of 2 earlier, so we need to dec once more to free it
        // but only if all cores are in (or we reset / reinit those that failed)
        // TODO after we parse ACPI tables
-       if (num_cpus == 8) // TODO - ghetto coded for our 8 way SMPs
+       if (num_cores == 8) // TODO - ghetto coded for our 8 way SMPs
                page_decref(pa2page(trampoline_pg));
        // Dealloc the temp shared stack
        page_decref(smp_stack);
                page_decref(pa2page(trampoline_pg));
        // Dealloc the temp shared stack
        page_decref(smp_stack);
@@ -231,7 +231,7 @@ void smp_boot(void)
        init_smp_call_function();
 
        /* Final core initialization */
        init_smp_call_function();
 
        /* Final core initialization */
-       init_barrier(&generic_barrier, num_cpus);
+       init_barrier(&generic_barrier, num_cores);
        /* This will break the cores out of their hlt in smp_entry.S */
        send_broadcast_ipi(I_POKE_CORE);
        smp_final_core_init();  /* need to init ourselves as well */
        /* This will break the cores out of their hlt in smp_entry.S */
        send_broadcast_ipi(I_POKE_CORE);
        smp_final_core_init();  /* need to init ourselves as well */
@@ -255,7 +255,7 @@ uintptr_t smp_main(void)
                cprintf("I am the Boot Strap Processor\n");
        else
                cprintf("I am an Application Processor\n");
                cprintf("I am the Boot Strap Processor\n");
        else
                cprintf("I am an Application Processor\n");
-       cprintf("Num_Cpus: %d\n\n", num_cpus);
+       cprintf("Num_Cores: %d\n\n", num_cores);
        */
        /* set up initial mappings.  core0 will adjust it later */
        unsigned long my_hw_id = lapic_get_id();
        */
        /* set up initial mappings.  core0 will adjust it later */
        unsigned long my_hw_id = lapic_get_id();
index 92fa62a..0592302 100644 (file)
@@ -78,7 +78,7 @@ long_mode:
        mov             %ax, %fs
        mov             %ax, %gs
        lldt    %ax
        mov             %ax, %fs
        mov             %ax, %gs
        lldt    %ax
-       incl    num_cpus                # uint32_t
+       incl    num_cores               # uint32_t
        movq    (smp_stack_top), %rsp
        movq    $0, %rbp                # so backtrace works
        # We're on the trampoline, but want to be in the real location of the smp
        movq    (smp_stack_top), %rsp
        movq    $0, %rbp                # so backtrace works
        # We're on the trampoline, but want to be in the real location of the smp
index 52c409f..162d16b 100644 (file)
@@ -159,11 +159,11 @@ void idt_init(void)
        pic_remap();
        pic_mask_all();
 
        pic_remap();
        pic_mask_all();
 
-       int ncleft = MAX_NUM_CPUS;
+       int ncleft = MAX_NUM_CORES;
 
        ncleft = mpsinit(ncleft);
        ncleft = mpacpi(ncleft);
 
        ncleft = mpsinit(ncleft);
        ncleft = mpacpi(ncleft);
-       printk("MP and ACPI found %d cores\n", MAX_NUM_CPUS - ncleft);
+       printk("MP and ACPI found %d cores\n", MAX_NUM_CORES - ncleft);
 
        apiconline();
        ioapiconline();
 
        apiconline();
        ioapiconline();
@@ -560,7 +560,7 @@ static int route_irq_h(struct irq_handler *irq_h, int os_coreid)
                       irq_h->apic_vector, irq_h->type);
                return -1;
        }
                       irq_h->apic_vector, irq_h->type);
                return -1;
        }
-       if (os_coreid >= MAX_NUM_CPUS) {
+       if (os_coreid >= MAX_NUM_CORES) {
                printk("[kernel] os_coreid %d out of range!\n", os_coreid);
                return -1;
        }
                printk("[kernel] os_coreid %d out of range!\n", os_coreid);
                return -1;
        }
index 25c31e9..34428af 100644 (file)
@@ -94,7 +94,7 @@ int vmm_struct_init(struct proc *p, unsigned int nr_guest_pcores, int flags)
        }
        /* Set this early, so cleanup checks the gpc array */
        vmm->vmmcp = TRUE;
        }
        /* Set this early, so cleanup checks the gpc array */
        vmm->vmmcp = TRUE;
-       nr_guest_pcores = MIN(nr_guest_pcores, num_cpus);
+       nr_guest_pcores = MIN(nr_guest_pcores, num_cores);
        vmm->amd = 0;
        vmm->guest_pcores = kzmalloc(sizeof(void*) * nr_guest_pcores, KMALLOC_WAIT);
        for (i = 0; i < nr_guest_pcores; i++) {
        vmm->amd = 0;
        vmm->guest_pcores = kzmalloc(sizeof(void*) * nr_guest_pcores, KMALLOC_WAIT);
        for (i = 0; i < nr_guest_pcores; i++) {
index a029186..51a08aa 100644 (file)
@@ -53,7 +53,7 @@
 #define CPUID_PSE_SUPPORT                      0x00000008
 
 /* Arch Constants */
 #define CPUID_PSE_SUPPORT                      0x00000008
 
 /* Arch Constants */
-#define MAX_NUM_CPUS                           255
+#define MAX_NUM_CORES                          255
 
 #define X86_REG_BP                                     "rbp"
 #define X86_REG_SP                                     "rsp"
 
 #define X86_REG_BP                                     "rbp"
 #define X86_REG_SP                                     "rsp"
index 6a66287..fda4525 100644 (file)
@@ -846,7 +846,7 @@ int pickcore(int mycolor, int index)
        if (slit == NULL) {
                return 0;
        }
        if (slit == NULL) {
                return 0;
        }
-       ncorepercol = num_cpus / slit->rowlen;
+       ncorepercol = num_cores / slit->rowlen;
        color = slit->e[mycolor][index / ncorepercol].dom;
        return color * ncorepercol + index % ncorepercol;
 }
        color = slit->e[mycolor][index / ncorepercol].dom;
        return color * ncorepercol + index % ncorepercol;
 }
index 367445d..697c765 100644 (file)
@@ -181,12 +181,12 @@ static void kprofinit(void)
        /* no, i'm not sure how we should do this yet. */
        int alloc_cpu_buffers(void);
        alloc_cpu_buffers();
        /* no, i'm not sure how we should do this yet. */
        int alloc_cpu_buffers(void);
        alloc_cpu_buffers();
-       oprof_alarms = kzmalloc(sizeof(struct alarm_waiter) * num_cpus,
+       oprof_alarms = kzmalloc(sizeof(struct alarm_waiter) * num_cores,
                                KMALLOC_WAIT);
        if (!oprof_alarms)
                error(Enomem);
 
                                KMALLOC_WAIT);
        if (!oprof_alarms)
                error(Enomem);
 
-       for (int i = 0; i < num_cpus; i++)
+       for (int i = 0; i < num_cores; i++)
                init_awaiter_irq(&oprof_alarms[i], oprof_alarm_handler);
 
        kprof.systrace = qopen(2 << 20, 0, 0, 0);
                init_awaiter_irq(&oprof_alarms[i], oprof_alarm_handler);
 
        kprof.systrace = qopen(2 << 20, 0, 0, 0);
@@ -248,7 +248,7 @@ kprofclose(struct chan*unused)
 static size_t mpstat_len(void)
 {
        size_t each_row = 7 + NR_CPU_STATES * 26;
 static size_t mpstat_len(void)
 {
        size_t each_row = 7 + NR_CPU_STATES * 26;
-       return each_row * (num_cpus + 1) + 1;
+       return each_row * (num_cores + 1) + 1;
 }
 
 static long mpstat_read(void *va, long n, int64_t off)
 }
 
 static long mpstat_read(void *va, long n, int64_t off)
@@ -269,7 +269,7 @@ static long mpstat_read(void *va, long n, int64_t off)
                len += snprintf(buf + len, bufsz - len, "%23s%s", cpu_state_names[j],
                                j != NR_CPU_STATES - 1 ? "   " : "  \n");
 
                len += snprintf(buf + len, bufsz - len, "%23s%s", cpu_state_names[j],
                                j != NR_CPU_STATES - 1 ? "   " : "  \n");
 
-       for (int i = 0; i < num_cpus; i++) {
+       for (int i = 0; i < num_cores; i++) {
                pcpui = &per_cpu_info[i];
                cpu_total = 0;
                len += snprintf(buf + len, bufsz - len, "%5d: ", i);
                pcpui = &per_cpu_info[i];
                cpu_total = 0;
                len += snprintf(buf + len, bufsz - len, "%5d: ", i);
@@ -293,7 +293,7 @@ static size_t mpstatraw_len(void)
 {
        size_t header_row = 27 + NR_CPU_STATES * 7 + 1;
        size_t cpu_row = 7 + NR_CPU_STATES * 17;
 {
        size_t header_row = 27 + NR_CPU_STATES * 7 + 1;
        size_t cpu_row = 7 + NR_CPU_STATES * 17;
-       return header_row + cpu_row * num_cpus + 1;
+       return header_row + cpu_row * num_cores + 1;
 }
 
 static long mpstatraw_read(void *va, long n, int64_t off)
 }
 
 static long mpstatraw_read(void *va, long n, int64_t off)
@@ -306,14 +306,14 @@ static long mpstatraw_read(void *va, long n, int64_t off)
        /* could spit it all out in binary, though then it'd be harder to process
         * the data across a mnt (if we export #K).  probably not a big deal. */
 
        /* could spit it all out in binary, though then it'd be harder to process
         * the data across a mnt (if we export #K).  probably not a big deal. */
 
-       /* header line: version, num_cpus, tsc freq, state names */
-       len += snprintf(buf + len, bufsz - len, "v%03d %5d %16llu", 1, num_cpus,
+       /* header line: version, num_cores, tsc freq, state names */
+       len += snprintf(buf + len, bufsz - len, "v%03d %5d %16llu", 1, num_cores,
                        system_timing.tsc_freq);
        for (int j = 0; j < NR_CPU_STATES; j++)
                len += snprintf(buf + len, bufsz - len, " %6s", cpu_state_names[j]);
        len += snprintf(buf + len, bufsz - len, "\n");
 
                        system_timing.tsc_freq);
        for (int j = 0; j < NR_CPU_STATES; j++)
                len += snprintf(buf + len, bufsz - len, " %6s", cpu_state_names[j]);
        len += snprintf(buf + len, bufsz - len, "\n");
 
-       for (int i = 0; i < num_cpus; i++) {
+       for (int i = 0; i < num_cores; i++) {
                pcpui = &per_cpu_info[i];
                len += snprintf(buf + len, bufsz - len, "%5d: ", i);
                for (int j = 0; j < NR_CPU_STATES; j++) {
                pcpui = &per_cpu_info[i];
                len += snprintf(buf + len, bufsz - len, "%5d: ", i);
                for (int j = 0; j < NR_CPU_STATES; j++) {
@@ -495,11 +495,11 @@ kprofwrite(struct chan *c, void *a, long n, int64_t unused)
                        if (!strcmp(cb->f[1], "period")) {
                                oprof_timer_period = strtoul(cb->f[2], 0, 10);
                        } else if (!strcmp(cb->f[1], "all")) {
                        if (!strcmp(cb->f[1], "period")) {
                                oprof_timer_period = strtoul(cb->f[2], 0, 10);
                        } else if (!strcmp(cb->f[1], "all")) {
-                               for (int i = 0; i < num_cpus; i++)
+                               for (int i = 0; i < num_cores; i++)
                                        manage_oprof_timer(i, cb);
                        } else {
                                int pcoreid = strtoul(cb->f[1], 0, 10);
                                        manage_oprof_timer(i, cb);
                        } else {
                                int pcoreid = strtoul(cb->f[1], 0, 10);
-                               if (pcoreid >= num_cpus)
+                               if (pcoreid >= num_cores)
                                        error("no such coreid %d", pcoreid);
                                manage_oprof_timer(pcoreid, cb);
                        }
                                        error("no such coreid %d", pcoreid);
                                manage_oprof_timer(pcoreid, cb);
                        }
@@ -534,7 +534,7 @@ kprofwrite(struct chan *c, void *a, long n, int64_t unused)
                if (cb->nf < 1)
                        error("mpstat bad option (reset|ipi|on|off)");
                if (!strcmp(cb->f[0], "reset")) {
                if (cb->nf < 1)
                        error("mpstat bad option (reset|ipi|on|off)");
                if (!strcmp(cb->f[0], "reset")) {
-                       for (int i = 0; i < num_cpus; i++)
+                       for (int i = 0; i < num_cores; i++)
                                reset_cpu_state_ticks(i);
                } else if (!strcmp(cb->f[0], "on")) {
                        /* TODO: enable the ticks */ ;
                                reset_cpu_state_ticks(i);
                } else if (!strcmp(cb->f[0], "on")) {
                        /* TODO: enable the ticks */ ;
index e2651df..7bd059a 100644 (file)
@@ -97,8 +97,8 @@ struct nix {
        void *image;
        unsigned long imagesize;
        int id;
        void *image;
        unsigned long imagesize;
        int id;
-       /* we could dynamically alloc one of these with num_cpus */
-       DECLARE_BITMAP(cpus, MAX_NUM_CPUS);
+       /* we could dynamically alloc one of these with num_cores */
+       DECLARE_BITMAP(cpus, MAX_NUM_CORES);
 };
 
 static spinlock_t nixlock = SPINLOCK_INITIALIZER_IRQSAVE;
 };
 
 static spinlock_t nixlock = SPINLOCK_INITIALIZER_IRQSAVE;
@@ -342,7 +342,7 @@ static struct chan *nixopen(struct chan *c, int omode)
                v->imagesize = img_size;
                printk("nix image is %p with %d bytes\n", v->image, v->imagesize);
                c->aux = v;
                v->imagesize = img_size;
                printk("nix image is %p with %d bytes\n", v->image, v->imagesize);
                c->aux = v;
-               bitmap_zero(v->cpus, MAX_NUM_CPUS);
+               bitmap_zero(v->cpus, MAX_NUM_CORES);
                memcpy(v->image, it, sizeof(it));
                break;
        case Qstat:
                memcpy(v->image, it, sizeof(it));
                break;
        case Qstat:
@@ -486,7 +486,7 @@ static long nixwrite(struct chan *c, void *ubuf, long n, int64_t off)
                        set_bit(core, nix->cpus);
                } else if (!strcmp(cb->f[0], "check")) {
                        int i;
                        set_bit(core, nix->cpus);
                } else if (!strcmp(cb->f[0], "check")) {
                        int i;
-                       for(i = 0; i < MAX_NUM_CPUS; i++) {
+                       for(i = 0; i < MAX_NUM_CORES; i++) {
                                if (!test_bit(i, nix->cpus))
                                        continue;
                                printk("Core %d is available to nix%d\n", i, nix->id);
                                if (!test_bit(i, nix->cpus))
                                        continue;
                                printk("Core %d is available to nix%d\n", i, nix->id);
index 442de35..44c4e95 100644 (file)
@@ -52,7 +52,7 @@ static void bnx2x_add_all_napi(struct bnx2x *bp)
 
 static int bnx2x_calc_num_queues(struct bnx2x *bp)
 {
 
 static int bnx2x_calc_num_queues(struct bnx2x *bp)
 {
-       /* default is min(8, num_cpus) in Linux.  we'll set it elsewhere */
+       /* default is min(8, num_cores) in Linux.  we'll set it elsewhere */
        int nq = bnx2x_num_queues ? : 8;
 
        /* Reduce memory usage in kdump environment by using only one queue */
        int nq = bnx2x_num_queues ? : 8;
 
        /* Reduce memory usage in kdump environment by using only one queue */
index d661a99..11a9a69 100644 (file)
@@ -184,7 +184,7 @@ static inline void poke_init(struct poke_tracker *tracker, void (*func)(void*))
 typedef struct checklist_mask {
        // only need an uint8_t, but we need the bits[] to be word aligned
        uint32_t size;
 typedef struct checklist_mask {
        // only need an uint8_t, but we need the bits[] to be word aligned
        uint32_t size;
-       volatile uint8_t bits[MAX_NUM_CPUS];
+       volatile uint8_t bits[MAX_NUM_CORES];
 } checklist_mask_t;
 
 // mask contains an unspecified array, so it needs to be at the bottom
 } checklist_mask_t;
 
 // mask contains an unspecified array, so it needs to be at the bottom
index 6211846..96f7e4a 100644 (file)
@@ -28,8 +28,8 @@ typedef struct procdata {
        struct resource_req             res_req[MAX_NUM_RESOURCES];
        struct event_queue              *kernel_evts[MAX_NR_EVENT];
        /* Long range, would like these to be mapped in lazily, as the vcores are
        struct resource_req             res_req[MAX_NUM_RESOURCES];
        struct event_queue              *kernel_evts[MAX_NR_EVENT];
        /* Long range, would like these to be mapped in lazily, as the vcores are
-        * requested.  Sharing MAX_NUM_CPUS is a bit weird too. */
-       struct preempt_data             vcore_preempt_data[MAX_NUM_CPUS];
+        * requested.  Sharing MAX_NUM_CORES is a bit weird too. */
+       struct preempt_data             vcore_preempt_data[MAX_NUM_CORES];
 } procdata_t;
 
 #define PROCDATA_NUM_PAGES  ((sizeof(procdata_t)-1)/PGSIZE + 1)
 } procdata_t;
 
 #define PROCDATA_NUM_PAGES  ((sizeof(procdata_t)-1)/PGSIZE + 1)
index 306a2a5..c11c0c1 100644 (file)
@@ -57,9 +57,9 @@ typedef struct procinfo {
         * rebuild glibc. */
        bool is_mcp;                    /* is in multi mode */
        unsigned long           res_grant[MAX_NUM_RESOURCES];
         * rebuild glibc. */
        bool is_mcp;                    /* is in multi mode */
        unsigned long           res_grant[MAX_NUM_RESOURCES];
-       struct vcore            vcoremap[MAX_NUM_CPUS];
+       struct vcore            vcoremap[MAX_NUM_CORES];
        uint32_t                        num_vcores;
        uint32_t                        num_vcores;
-       struct pcore            pcoremap[MAX_NUM_CPUS];
+       struct pcore            pcoremap[MAX_NUM_CORES];
        seq_ctr_t                       coremap_seqctr;
 } procinfo_t;
 #define PROCINFO_NUM_PAGES  ((sizeof(procinfo_t)-1)/PGSIZE + 1)        
        seq_ctr_t                       coremap_seqctr;
 } procinfo_t;
 #define PROCINFO_NUM_PAGES  ((sizeof(procinfo_t)-1)/PGSIZE + 1)        
index fd62d33..c9dae0b 100644 (file)
@@ -85,8 +85,8 @@ struct per_cpu_info {
 
 typedef struct per_cpu_info  per_cpu_info_t;
 
 
 typedef struct per_cpu_info  per_cpu_info_t;
 
-extern per_cpu_info_t per_cpu_info[MAX_NUM_CPUS];
-extern volatile uint32_t num_cpus;
+extern per_cpu_info_t per_cpu_info[MAX_NUM_CORES];
+extern volatile uint32_t num_cores;
 
 /* SMP bootup functions */
 void smp_boot(void);
 
 /* SMP bootup functions */
 void smp_boot(void);
index e541a78..a10ebfc 100644 (file)
@@ -456,7 +456,7 @@ void print_pcpu_chains(void)
        struct timer_chain *pcpu_chain;
        printk("PCPU Chains:  It is now %llu\n", read_tsc());
 
        struct timer_chain *pcpu_chain;
        printk("PCPU Chains:  It is now %llu\n", read_tsc());
 
-       for (int i = 0; i < num_cpus; i++) {
+       for (int i = 0; i < num_cores; i++) {
                pcpu_chain = &per_cpu_info[i].tchain;
                print_chain(pcpu_chain);
        }
                pcpu_chain = &per_cpu_info[i].tchain;
                print_chain(pcpu_chain);
        }
index 04f16ba..880839b 100644 (file)
@@ -23,8 +23,8 @@
  * address wrap-around. */
 static bool vcoreid_is_safe(uint32_t vcoreid)
 {
  * address wrap-around. */
 static bool vcoreid_is_safe(uint32_t vcoreid)
 {
-       /* MAX_NUM_VCORES == MAX_NUM_CPUS (check procinfo/procdata) */
-       return vcoreid < MAX_NUM_CPUS;
+       /* MAX_NUM_VCORES == MAX_NUM_CORES (check procinfo/procdata) */
+       return vcoreid < MAX_NUM_CORES;
 }
 
 /* Note these three helpers return the user address of the mbox, not the KVA.
 }
 
 /* Note these three helpers return the user address of the mbox, not the KVA.
index 423c2c5..c978053 100644 (file)
@@ -190,7 +190,7 @@ void __diediedie(uint32_t srcid, uint32_t code, uint32_t a1, uint32_t a2)
 void appserver_die(uintptr_t code)
 {
        int i;
 void appserver_die(uintptr_t code)
 {
        int i;
-       for(i = 0; i < num_cpus; i++)
+       for(i = 0; i < num_cores; i++)
                if(i != core_id())
                        while(send_kernel_message(i, (amr_t)&__diediedie, code, 0, 0,
                                                  KMSG_IMMEDIATE));
                if(i != core_id())
                        while(send_kernel_message(i, (amr_t)&__diediedie, code, 0, 0,
                                                  KMSG_IMMEDIATE));
index bf05361..35d0803 100644 (file)
@@ -251,7 +251,7 @@ barrier_t test_cpu_array;
 bool test_barrier(void)
 {
        cprintf("Core 0 initializing barrier\n");
 bool test_barrier(void)
 {
        cprintf("Core 0 initializing barrier\n");
-       init_barrier(&test_cpu_array, num_cpus);
+       init_barrier(&test_cpu_array, num_cores);
        cprintf("Core 0 asking all cores to print ids, barrier, rinse, repeat\n");
        smp_call_function_all(test_barrier_handler, NULL, 0);
 
        cprintf("Core 0 asking all cores to print ids, barrier, rinse, repeat\n");
        smp_call_function_all(test_barrier_handler, NULL, 0);
 
@@ -400,7 +400,7 @@ static void test_checklist_handler(struct hw_trapframe *hw_tf, void *data)
 // TODO: Add assertions
 bool test_checklists(void)
 {
 // TODO: Add assertions
 bool test_checklists(void)
 {
-       INIT_CHECKLIST(a_list, MAX_NUM_CPUS);
+       INIT_CHECKLIST(a_list, MAX_NUM_CORES);
        the_global_list = &a_list;
        printk("Checklist Build, mask size: %d\n", sizeof(a_list.mask.bits));
        printk("mask\n");
        the_global_list = &a_list;
        printk("Checklist Build, mask size: %d\n", sizeof(a_list.mask.bits));
        printk("mask\n");
@@ -410,12 +410,12 @@ bool test_checklists(void)
        PRINT_BITMASK(a_list.mask.bits, a_list.mask.size);
 
        CLR_BITMASK(a_list.mask.bits, a_list.mask.size);
        PRINT_BITMASK(a_list.mask.bits, a_list.mask.size);
 
        CLR_BITMASK(a_list.mask.bits, a_list.mask.size);
-       INIT_CHECKLIST_MASK(a_mask, MAX_NUM_CPUS);
-       FILL_BITMASK(a_mask.bits, num_cpus);
+       INIT_CHECKLIST_MASK(a_mask, MAX_NUM_CORES);
+       FILL_BITMASK(a_mask.bits, num_cores);
        //CLR_BITMASK_BIT(a_mask.bits, core_id());
        //SET_BITMASK_BIT(a_mask.bits, 1);
        //printk("New mask (1, 17, 25):\n");
        //CLR_BITMASK_BIT(a_mask.bits, core_id());
        //SET_BITMASK_BIT(a_mask.bits, 1);
        //printk("New mask (1, 17, 25):\n");
-       printk("Created new mask, filled up to num_cpus\n");
+       printk("Created new mask, filled up to num_cores\n");
        PRINT_BITMASK(a_mask.bits, a_mask.size);
        printk("committing new mask\n");
        commit_checklist_wait(&a_list, &a_mask);
        PRINT_BITMASK(a_mask.bits, a_mask.size);
        printk("committing new mask\n");
        commit_checklist_wait(&a_list, &a_mask);
@@ -471,7 +471,7 @@ bool test_smp_call_functions(void)
        smp_call_wait(waiter0);
        printk("\nCore %d: SMP Call All-Else Individually, in order (nowait):\n", me);
        printk("---------------------\n");
        smp_call_wait(waiter0);
        printk("\nCore %d: SMP Call All-Else Individually, in order (nowait):\n", me);
        printk("---------------------\n");
-       for(i = 1; i < num_cpus; i++)
+       for(i = 1; i < num_cores; i++)
                smp_call_function_single(i, test_hello_world_handler, NULL, 0);
        printk("\nCore %d: SMP Call Self (wait):\n", me);
        printk("---------------------\n");
                smp_call_function_single(i, test_hello_world_handler, NULL, 0);
        printk("\nCore %d: SMP Call Self (wait):\n", me);
        printk("---------------------\n");
@@ -479,7 +479,7 @@ bool test_smp_call_functions(void)
        smp_call_wait(waiter0);
        printk("\nCore %d: SMP Call All-Else Individually, in order (wait):\n", me);
        printk("---------------------\n");
        smp_call_wait(waiter0);
        printk("\nCore %d: SMP Call All-Else Individually, in order (wait):\n", me);
        printk("---------------------\n");
-       for(i = 1; i < num_cpus; i++)
+       for(i = 1; i < num_cores; i++)
        {
                smp_call_function_single(i, test_hello_world_handler, NULL, &waiter0);
                smp_call_wait(waiter0);
        {
                smp_call_function_single(i, test_hello_world_handler, NULL, &waiter0);
                smp_call_wait(waiter0);
@@ -490,18 +490,18 @@ bool test_smp_call_functions(void)
        smp_call_function_all(test_incrementer_handler, &b, 0);
        smp_call_function_all(test_incrementer_handler, &c, 0);
        // if i can clobber a previous IPI, the interleaving might do it
        smp_call_function_all(test_incrementer_handler, &b, 0);
        smp_call_function_all(test_incrementer_handler, &c, 0);
        // if i can clobber a previous IPI, the interleaving might do it
-       smp_call_function_single(1 % num_cpus, test_incrementer_handler, &a, 0);
-       smp_call_function_single(2 % num_cpus, test_incrementer_handler, &b, 0);
-       smp_call_function_single(3 % num_cpus, test_incrementer_handler, &c, 0);
-       smp_call_function_single(4 % num_cpus, test_incrementer_handler, &a, 0);
-       smp_call_function_single(5 % num_cpus, test_incrementer_handler, &b, 0);
-       smp_call_function_single(6 % num_cpus, test_incrementer_handler, &c, 0);
+       smp_call_function_single(1 % num_cores, test_incrementer_handler, &a, 0);
+       smp_call_function_single(2 % num_cores, test_incrementer_handler, &b, 0);
+       smp_call_function_single(3 % num_cores, test_incrementer_handler, &c, 0);
+       smp_call_function_single(4 % num_cores, test_incrementer_handler, &a, 0);
+       smp_call_function_single(5 % num_cores, test_incrementer_handler, &b, 0);
+       smp_call_function_single(6 % num_cores, test_incrementer_handler, &c, 0);
        smp_call_function_all(test_incrementer_handler, &a, 0);
        smp_call_function_all(test_incrementer_handler, &a, 0);
-       smp_call_function_single(3 % num_cpus, test_incrementer_handler, &c, 0);
+       smp_call_function_single(3 % num_cores, test_incrementer_handler, &c, 0);
        smp_call_function_all(test_incrementer_handler, &b, 0);
        smp_call_function_all(test_incrementer_handler, &b, 0);
-       smp_call_function_single(1 % num_cpus, test_incrementer_handler, &a, 0);
+       smp_call_function_single(1 % num_cores, test_incrementer_handler, &a, 0);
        smp_call_function_all(test_incrementer_handler, &c, 0);
        smp_call_function_all(test_incrementer_handler, &c, 0);
-       smp_call_function_single(2 % num_cpus, test_incrementer_handler, &b, 0);
+       smp_call_function_single(2 % num_cores, test_incrementer_handler, &b, 0);
        // wait, so we're sure the others finish before printing.
        // without this, we could (and did) get 19,18,19, since the B_inc
        // handler didn't finish yet
        // wait, so we're sure the others finish before printing.
        // without this, we could (and did) get 19,18,19, since the B_inc
        // handler didn't finish yet
@@ -1529,9 +1529,9 @@ bool test_cv(void)
        printk("test_cv: signal without waiting complete\n");
 
        /* Test 1: single / minimal shit */
        printk("test_cv: signal without waiting complete\n");
 
        /* Test 1: single / minimal shit */
-       nr_msgs = num_cpus - 1; /* not using cpu 0 */
+       nr_msgs = num_cores - 1; /* not using cpu 0 */
        atomic_init(&counter, nr_msgs);
        atomic_init(&counter, nr_msgs);
-       for (int i = 1; i < num_cpus; i++)
+       for (int i = 1; i < num_cores; i++)
                send_kernel_message(i, __test_cv_waiter, 0, 0, 0, KMSG_ROUTINE);
        udelay(1000000);
        cv_signal(cv);
                send_kernel_message(i, __test_cv_waiter, 0, 0, 0, KMSG_ROUTINE);
        udelay(1000000);
        cv_signal(cv);
@@ -1551,7 +1551,7 @@ bool test_cv(void)
        nr_msgs = 0x500;        /* any more than 0x20000 could go OOM */
        atomic_init(&counter, nr_msgs);
        for (int i = 0; i < nr_msgs; i++) {
        nr_msgs = 0x500;        /* any more than 0x20000 could go OOM */
        atomic_init(&counter, nr_msgs);
        for (int i = 0; i < nr_msgs; i++) {
-               int cpu = (i % (num_cpus - 1)) + 1;
+               int cpu = (i % (num_cores - 1)) + 1;
                if (atomic_read(&counter) % 5)
                        send_kernel_message(cpu, __test_cv_waiter, 0, 0, 0, KMSG_ROUTINE);
                else
                if (atomic_read(&counter) % 5)
                        send_kernel_message(cpu, __test_cv_waiter, 0, 0, 0, KMSG_ROUTINE);
                else
@@ -1811,8 +1811,8 @@ bool test_rwlock(void)
        }
                
        /* send 4 messages to each non core 0 */
        }
                
        /* send 4 messages to each non core 0 */
-       atomic_init(&rwlock_counter, (num_cpus - 1) * 4);
-       for (int i = 1; i < num_cpus; i++)
+       atomic_init(&rwlock_counter, (num_cores - 1) * 4);
+       for (int i = 1; i < num_cores; i++)
                for (int j = 0; j < 4; j++)
                        send_kernel_message(i, __test_rwlock, 0, 0, 0, KMSG_ROUTINE);
        while (atomic_read(&rwlock_counter))
                for (int j = 0; j < 4; j++)
                        send_kernel_message(i, __test_rwlock, 0, 0, 0, KMSG_ROUTINE);
        while (atomic_read(&rwlock_counter))
@@ -1866,10 +1866,10 @@ bool test_rv(void)
        printk("test_rv: wakeup without sleeping complete\n");
 
        /* Test 1: a few sleepers */
        printk("test_rv: wakeup without sleeping complete\n");
 
        /* Test 1: a few sleepers */
-       nr_msgs = num_cpus - 1; /* not using cpu 0 */
+       nr_msgs = num_cores - 1; /* not using cpu 0 */
        atomic_init(&counter, nr_msgs);
        state = FALSE;
        atomic_init(&counter, nr_msgs);
        state = FALSE;
-       for (int i = 1; i < num_cpus; i++)
+       for (int i = 1; i < num_cores; i++)
                send_kernel_message(i, __test_rv_sleeper, 0, 0, 0, KMSG_ROUTINE);
        udelay(1000000);
        cmb();
                send_kernel_message(i, __test_rv_sleeper, 0, 0, 0, KMSG_ROUTINE);
        udelay(1000000);
        cmb();
@@ -1887,7 +1887,7 @@ bool test_rv(void)
        nr_msgs = 0x500;        /* any more than 0x20000 could go OOM */
        atomic_init(&counter, nr_msgs);
        for (int i = 0; i < nr_msgs; i++) {
        nr_msgs = 0x500;        /* any more than 0x20000 could go OOM */
        atomic_init(&counter, nr_msgs);
        for (int i = 0; i < nr_msgs; i++) {
-               int cpu = (i % (num_cpus - 1)) + 1;
+               int cpu = (i % (num_cores - 1)) + 1;
                /* timeouts from 0ms ..5000ms (enough that they should wake via cond */
                if (atomic_read(&counter) % 5)
                        send_kernel_message(cpu, __test_rv_sleeper_timeout, i * 4, 0, 0,
                /* timeouts from 0ms ..5000ms (enough that they should wake via cond */
                if (atomic_read(&counter) % 5)
                        send_kernel_message(cpu, __test_rv_sleeper_timeout, i * 4, 0, 0,
index c9b8a0e..be80396 100644 (file)
@@ -135,7 +135,7 @@ void manager_brho(void)
 
 #if 0 /* ancient tests below: (keeping around til we ditch the manager) */
        // for testing taking cores, check in case 1 for usage
 
 #if 0 /* ancient tests below: (keeping around til we ditch the manager) */
        // for testing taking cores, check in case 1 for usage
-       uint32_t corelist[MAX_NUM_CPUS];
+       uint32_t corelist[MAX_NUM_CORES];
        uint32_t num = 3;
        struct file *temp_f;
        static struct proc *p;
        uint32_t num = 3;
        struct file *temp_f;
        static struct proc *p;
@@ -285,7 +285,7 @@ void manager_yuzhu()
        static struct proc *p;
 
        // for testing taking cores, check in case 1 for usage
        static struct proc *p;
 
        // for testing taking cores, check in case 1 for usage
-       uint32_t corelist[MAX_NUM_CPUS];
+       uint32_t corelist[MAX_NUM_CORES];
        uint32_t num = 3;
 
        //create_server(init_num_cores, loop);
        uint32_t num = 3;
 
        //create_server(init_num_cores, loop);
index 0f94453..d3d9538 100644 (file)
@@ -228,7 +228,7 @@ static bool print_all_info(void)
 
 int mon_cpuinfo(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
 
 int mon_cpuinfo(int argc, char **argv, struct hw_trapframe *hw_tf)
 {
-       cprintf("Number of CPUs detected: %d\n", num_cpus);
+       cprintf("Number of Cores detected: %d\n", num_cores);
        cprintf("Calling CPU's ID: 0x%08x\n", core_id());
 
        if (argc < 2)
        cprintf("Calling CPU's ID: 0x%08x\n", core_id());
 
        if (argc < 2)
@@ -736,11 +736,11 @@ int mon_trace(int argc, char **argv, struct hw_trapframe *hw_tf)
                core = strtol(argv[2], 0, 0);
                if (core < 0) {
                        printk("Sending NMIs to all cores:\n");
                core = strtol(argv[2], 0, 0);
                if (core < 0) {
                        printk("Sending NMIs to all cores:\n");
-                       for (int i = 0; i < num_cpus; i++)
+                       for (int i = 0; i < num_cores; i++)
                                send_nmi(i);
                } else {
                        printk("Sending NMI core %d:\n", core);
                                send_nmi(i);
                } else {
                        printk("Sending NMI core %d:\n", core);
-                       if (core >= num_cpus) {
+                       if (core >= num_cores) {
                                printk("No such core!  Maybe it's in another cell...\n");
                                return 1;
                        }
                                printk("No such core!  Maybe it's in another cell...\n");
                                return 1;
                        }
@@ -796,7 +796,7 @@ int mon_monitor(int argc, char **argv, struct hw_trapframe *hw_tf)
                return 1;
        }
        uint32_t core = strtol(argv[1], 0, 0);
                return 1;
        }
        uint32_t core = strtol(argv[1], 0, 0);
-       if (core >= num_cpus) {
+       if (core >= num_cores) {
                printk("No such core!  Maybe it's in another cell...\n");
                return 1;
        }
                printk("No such core!  Maybe it's in another cell...\n");
                return 1;
        }
index 5036d7a..cf06381 100644 (file)
@@ -146,11 +146,11 @@ int alloc_cpu_buffers(void)
        qnoblock(opq, 1);
        if (!op_cpu_buffer) {
                op_cpu_buffer =
        qnoblock(opq, 1);
        if (!op_cpu_buffer) {
                op_cpu_buffer =
-                       kzmalloc(sizeof(*op_cpu_buffer) * num_cpus, KMALLOC_WAIT);
+                       kzmalloc(sizeof(*op_cpu_buffer) * num_cores, KMALLOC_WAIT);
                if (!op_cpu_buffer)
                        goto fail;
 
                if (!op_cpu_buffer)
                        goto fail;
 
-               for (i = 0; i < num_cpus; i++) {
+               for (i = 0; i < num_cores; i++) {
                        struct oprofile_cpu_buffer *b = &op_cpu_buffer[i];
                        b->last_proc = NULL;
                        b->last_is_kernel = -1;
                        struct oprofile_cpu_buffer *b = &op_cpu_buffer[i];
                        b->last_proc = NULL;
                        b->last_is_kernel = -1;
@@ -423,7 +423,7 @@ void oprofile_cpubuf_flushall(int alloc)
        //print_func_entry();
        int core;
 
        //print_func_entry();
        int core;
 
-       for(core = 0; core < num_cpus; core++) {
+       for(core = 0; core < num_cores; core++) {
                oprofile_cpubuf_flushone(core, alloc);
        }
        //print_func_exit();
                oprofile_cpubuf_flushone(core, alloc);
        }
        //print_func_exit();
@@ -435,7 +435,7 @@ void oprofile_control_trace(int onoff)
        int core;
        struct oprofile_cpu_buffer *cpu_buf;
 
        int core;
        struct oprofile_cpu_buffer *cpu_buf;
 
-       for(core = 0; core < num_cpus; core++) {
+       for(core = 0; core < num_cores; core++) {
                cpu_buf = &op_cpu_buffer[core];
                cpu_buf->tracing = onoff;
 
                cpu_buf = &op_cpu_buffer[core];
                cpu_buf->tracing = onoff;
 
index 24e387b..5492415 100644 (file)
@@ -1603,7 +1603,7 @@ static void __proc_give_cores_running(struct proc *p, uint32_t *pc_arr,
 int __proc_give_cores(struct proc *p, uint32_t *pc_arr, uint32_t num)
 {
        /* should never happen: */
 int __proc_give_cores(struct proc *p, uint32_t *pc_arr, uint32_t num)
 {
        /* should never happen: */
-       assert(num + p->procinfo->num_vcores <= MAX_NUM_CPUS);
+       assert(num + p->procinfo->num_vcores <= MAX_NUM_CORES);
        switch (p->state) {
                case (PROC_RUNNABLE_S):
                case (PROC_RUNNING_S):
        switch (p->state) {
                case (PROC_RUNNABLE_S):
                case (PROC_RUNNING_S):
index 5c074f7..599ec55 100644 (file)
@@ -119,8 +119,8 @@ void schedule_init(void)
 {
        spin_lock(&sched_lock);
        /* init provisioning stuff */
 {
        spin_lock(&sched_lock);
        /* init provisioning stuff */
-       all_pcores = kmalloc(sizeof(struct sched_pcore) * num_cpus, 0);
-       memset(all_pcores, 0, sizeof(struct sched_pcore) * num_cpus);
+       all_pcores = kmalloc(sizeof(struct sched_pcore) * num_cores, 0);
+       memset(all_pcores, 0, sizeof(struct sched_pcore) * num_cores);
        assert(!core_id());             /* want the alarm on core0 for now */
        init_awaiter(&ksched_waiter, __ksched_tick);
        set_ksched_alarm();
        assert(!core_id());             /* want the alarm on core0 for now */
        init_awaiter(&ksched_waiter, __ksched_tick);
        set_ksched_alarm();
@@ -128,11 +128,11 @@ void schedule_init(void)
         * odds from 1..max-1.  otherwise, give them everything by 0 (default mgmt
         * core).  TODO: (CG/LL) better LL/CG mgmt */
 #ifndef CONFIG_DISABLE_SMT
         * odds from 1..max-1.  otherwise, give them everything by 0 (default mgmt
         * core).  TODO: (CG/LL) better LL/CG mgmt */
 #ifndef CONFIG_DISABLE_SMT
-       for (int i = 1; i < num_cpus; i++)
+       for (int i = 1; i < num_cores; i++)
                TAILQ_INSERT_TAIL(&idlecores, pcoreid2spc(i), alloc_next);
 #else
                TAILQ_INSERT_TAIL(&idlecores, pcoreid2spc(i), alloc_next);
 #else
-       assert(!(num_cpus % 2));
-       for (int i = 1; i < num_cpus; i += 2)
+       assert(!(num_cores % 2));
+       for (int i = 1; i < num_cores; i += 2)
                TAILQ_INSERT_TAIL(&idlecores, pcoreid2spc(i), alloc_next);
 #endif /* CONFIG_DISABLE_SMT */
        spin_unlock(&sched_lock);
                TAILQ_INSERT_TAIL(&idlecores, pcoreid2spc(i), alloc_next);
 #endif /* CONFIG_DISABLE_SMT */
        spin_unlock(&sched_lock);
@@ -611,7 +611,7 @@ int get_this_idle_core(int coreid)
 {
        struct sched_pcore *spc = pcoreid2spc(coreid);
        int ret = -1;
 {
        struct sched_pcore *spc = pcoreid2spc(coreid);
        int ret = -1;
-       assert((0 <= coreid) && (coreid < num_cpus));
+       assert((0 <= coreid) && (coreid < num_cores));
        spin_lock(&sched_lock);
        if (__spc_is_idle(pcoreid2spc(coreid)) && !spc->prov_proc) {
                assert(!spc->alloc_proc);
        spin_lock(&sched_lock);
        if (__spc_is_idle(pcoreid2spc(coreid)) && !spc->prov_proc) {
                assert(!spc->alloc_proc);
@@ -626,7 +626,7 @@ int get_this_idle_core(int coreid)
 void put_idle_core(int coreid)
 {
        struct sched_pcore *spc = pcoreid2spc(coreid);
 void put_idle_core(int coreid)
 {
        struct sched_pcore *spc = pcoreid2spc(coreid);
-       assert((0 <= coreid) && (coreid < num_cpus));
+       assert((0 <= coreid) && (coreid < num_cores));
        spin_lock(&sched_lock);
        TAILQ_INSERT_TAIL(&idlecores, spc, alloc_next);
        spin_unlock(&sched_lock);
        spin_lock(&sched_lock);
        TAILQ_INSERT_TAIL(&idlecores, spc, alloc_next);
        spin_unlock(&sched_lock);
@@ -637,9 +637,9 @@ uint32_t max_vcores(struct proc *p)
 {
 /* TODO: (CG/LL) */
 #ifdef CONFIG_DISABLE_SMT
 {
 /* TODO: (CG/LL) */
 #ifdef CONFIG_DISABLE_SMT
-       return num_cpus >> 1;
+       return num_cores >> 1;
 #else
 #else
-       return num_cpus - 1;    /* reserving core 0 */
+       return num_cores - 1;   /* reserving core 0 */
 #endif /* CONFIG_DISABLE_SMT */
 }
 
 #endif /* CONFIG_DISABLE_SMT */
 }
 
@@ -655,7 +655,7 @@ uint32_t max_vcores(struct proc *p)
 static void __core_request(struct proc *p, uint32_t amt_needed)
 {
        uint32_t nr_to_grant = 0;
 static void __core_request(struct proc *p, uint32_t amt_needed)
 {
        uint32_t nr_to_grant = 0;
-       uint32_t corelist[num_cpus];
+       uint32_t corelist[num_cores];
        struct sched_pcore *spc_i, *temp;
        struct proc *proc_to_preempt;
        bool success;
        struct sched_pcore *spc_i, *temp;
        struct proc *proc_to_preempt;
        bool success;
@@ -805,7 +805,7 @@ static bool is_ll_core(uint32_t pcoreid)
 static void __prov_track_alloc(struct proc *p, uint32_t pcoreid)
 {
        struct sched_pcore *spc;
 static void __prov_track_alloc(struct proc *p, uint32_t pcoreid)
 {
        struct sched_pcore *spc;
-       assert(pcoreid < num_cpus);             /* catch bugs */
+       assert(pcoreid < num_cores);    /* catch bugs */
        spc = pcoreid2spc(pcoreid);
        assert(spc->alloc_proc != p);   /* corruption or double-alloc */
        spc->alloc_proc = p;
        spc = pcoreid2spc(pcoreid);
        assert(spc->alloc_proc != p);   /* corruption or double-alloc */
        spc->alloc_proc = p;
@@ -821,7 +821,7 @@ static void __prov_track_alloc(struct proc *p, uint32_t pcoreid)
 static void __prov_track_dealloc(struct proc *p, uint32_t pcoreid)
 {
        struct sched_pcore *spc;
 static void __prov_track_dealloc(struct proc *p, uint32_t pcoreid)
 {
        struct sched_pcore *spc;
-       assert(pcoreid < num_cpus);             /* catch bugs */
+       assert(pcoreid < num_cores);    /* catch bugs */
        spc = pcoreid2spc(pcoreid);
        spc->alloc_proc = 0;
        /* if the pcore is prov to them and now deallocated, move lists */
        spc = pcoreid2spc(pcoreid);
        spc->alloc_proc = 0;
        /* if the pcore is prov to them and now deallocated, move lists */
@@ -850,7 +850,7 @@ int provision_core(struct proc *p, uint32_t pcoreid)
        struct sched_pcore_tailq *prov_list;
        /* Make sure we aren't asking for something that doesn't exist (bounds check
         * on the pcore array) */
        struct sched_pcore_tailq *prov_list;
        /* Make sure we aren't asking for something that doesn't exist (bounds check
         * on the pcore array) */
-       if (!(pcoreid < num_cpus)) {
+       if (!(pcoreid < num_cores)) {
                set_errno(ENXIO);
                return -1;
        }
                set_errno(ENXIO);
                return -1;
        }
@@ -945,7 +945,7 @@ void print_prov_map(void)
        struct sched_pcore *spc_i;
        /* Doing this unlocked, which is dangerous, but won't deadlock */
        printk("Which cores are provisioned to which procs:\n------------------\n");
        struct sched_pcore *spc_i;
        /* Doing this unlocked, which is dangerous, but won't deadlock */
        printk("Which cores are provisioned to which procs:\n------------------\n");
-       for (int i = 0; i < num_cpus; i++) {
+       for (int i = 0; i < num_cores; i++) {
                spc_i = pcoreid2spc(i);
                printk("Core %02d, prov: %d(%p) alloc: %d(%p)\n", i,
                       spc_i->prov_proc ? spc_i->prov_proc->pid : 0, spc_i->prov_proc,
                spc_i = pcoreid2spc(i);
                printk("Core %02d, prov: %d(%p) alloc: %d(%p)\n", i,
                       spc_i->prov_proc ? spc_i->prov_proc->pid : 0, spc_i->prov_proc,
index 701cfb6..d872459 100644 (file)
@@ -19,7 +19,7 @@
 #include <kdebug.h>
 #include <kmalloc.h>
 
 #include <kdebug.h>
 #include <kmalloc.h>
 
-struct per_cpu_info per_cpu_info[MAX_NUM_CPUS];
+struct per_cpu_info per_cpu_info[MAX_NUM_CORES];
 
 // tracks number of global waits on smp_calls, must be <= NUM_HANDLER_WRAPPERS
 atomic_t outstanding_calls = 0;
 
 // tracks number of global waits on smp_calls, must be <= NUM_HANDLER_WRAPPERS
 atomic_t outstanding_calls = 0;
@@ -148,7 +148,7 @@ void reset_cpu_state_ticks(int coreid)
 {
        struct per_cpu_info *pcpui = &per_cpu_info[coreid];
        uint64_t now_ticks;
 {
        struct per_cpu_info *pcpui = &per_cpu_info[coreid];
        uint64_t now_ticks;
-       if (coreid >= num_cpus)
+       if (coreid >= num_cores)
                return;
        /* need to update last_tick_cnt, so the current value doesn't get added in
         * next time we update */
                return;
        /* need to update last_tick_cnt, so the current value doesn't get added in
         * next time we update */
@@ -220,18 +220,18 @@ void pcpui_tr_foreach(int coreid, int type)
 
 void pcpui_tr_foreach_all(int type)
 {
 
 void pcpui_tr_foreach_all(int type)
 {
-       for (int i = 0; i < num_cpus; i++)
+       for (int i = 0; i < num_cores; i++)
                pcpui_tr_foreach(i, type);
 }
 
 void pcpui_tr_reset_all(void)
 {
                pcpui_tr_foreach(i, type);
 }
 
 void pcpui_tr_reset_all(void)
 {
-       for (int i = 0; i < num_cpus; i++)
+       for (int i = 0; i < num_cores; i++)
                trace_ring_reset(&per_cpu_info[i].traces);
 }
 
 void pcpui_tr_reset_and_clear_all(void)
 {
                trace_ring_reset(&per_cpu_info[i].traces);
 }
 
 void pcpui_tr_reset_and_clear_all(void)
 {
-       for (int i = 0; i < num_cpus; i++)
+       for (int i = 0; i < num_cores; i++)
                trace_ring_reset_and_clear(&per_cpu_info[i].traces);
 }
                trace_ring_reset_and_clear(&per_cpu_info[i].traces);
 }
index 35c13cf..cf28850 100644 (file)
@@ -280,7 +280,7 @@ void kmsg_queue_stat(void)
 {
        struct kernel_message *kmsg;
        bool immed_emp, routine_emp;
 {
        struct kernel_message *kmsg;
        bool immed_emp, routine_emp;
-       for (int i = 0; i < num_cpus; i++) {
+       for (int i = 0; i < num_cores; i++) {
                spin_lock_irqsave(&per_cpu_info[i].immed_amsg_lock);
                immed_emp = STAILQ_EMPTY(&per_cpu_info[i].immed_amsgs);
                spin_unlock_irqsave(&per_cpu_info[i].immed_amsg_lock);
                spin_lock_irqsave(&per_cpu_info[i].immed_amsg_lock);
                immed_emp = STAILQ_EMPTY(&per_cpu_info[i].immed_amsgs);
                spin_unlock_irqsave(&per_cpu_info[i].immed_amsg_lock);
index 9e19a45..55aff83 100644 (file)
@@ -1,6 +1,6 @@
 NETWORK_CARD ?= rtl8139
 CPU_MODEL ?= Nehalem
 NETWORK_CARD ?= rtl8139
 CPU_MODEL ?= Nehalem
-NUM_CPUS ?= 8
+NUM_CORES ?= 8
 MEMORY_SIZE ?= 1024
 KERNEL_BIN ?= obj/kern/akaros-kernel
 ENABLE_KVM ?= #-enable-kvm
 MEMORY_SIZE ?= 1024
 KERNEL_BIN ?= obj/kern/akaros-kernel
 ENABLE_KVM ?= #-enable-kvm
@@ -13,4 +13,4 @@ qemu: all qemu-run
 # See http://www.tuxation.com/setuid-on-shell-scripts.html
 qemu-run:
        qemu_launcher -s $(ENABLE_KVM) $(QEMU_NETWORK) -cpu $(CPU_MODEL) \
 # See http://www.tuxation.com/setuid-on-shell-scripts.html
 qemu-run:
        qemu_launcher -s $(ENABLE_KVM) $(QEMU_NETWORK) -cpu $(CPU_MODEL) \
-       -smp $(NUM_CPUS) -m $(MEMORY_SIZE) -kernel $(KERNEL_BIN) -nographic
+       -smp $(NUM_CORES) -m $(MEMORY_SIZE) -kernel $(KERNEL_BIN) -nographic