Version for Benchmarking.
authorGerd Zellweger <mail@gerdzellweger.com>
Sat, 25 Jan 2014 10:09:10 +0000 (11:09 +0100)
committerGerd Zellweger <mail@gerdzellweger.com>
Tue, 14 Oct 2014 06:50:10 +0000 (08:50 +0200)
- Added ap_dispatch lock to measure time to update.
- Benchmark main in x86boot.

kernel/arch/x86/startup_x86.c
kernel/arch/x86_64/init.c
kernel/arch/x86_64/init_ap_x86_64.S
kernel/syscall.c
usr/drivers/cpuboot/Hakefile
usr/drivers/cpuboot/init_ap_x86_64.S
usr/drivers/cpuboot/x86boot.c
usr/monitor/inter.c
usr/monitor/monitor_rpc_server.c
usr/monitor/monitor_server.c
usr/tests/hellotest/hellotest.c

index b72d0f3..d2411b2 100644 (file)
@@ -356,6 +356,17 @@ void kernel_startup(void)
                 debug(SUBSYS_STARTUP, "scheduling '%s' from restored state\n",
                       dst->name);
             }
+
+            // measure time to update
+            extern uint64_t x86_64_start_ap;
+            extern uint64_t x86_64_init_ap_dispatch;
+            volatile uint32_t *ap_dispatch = (volatile uint32_t *) local_phys_to_mem(
+                                             (lpaddr_t)&x86_64_init_ap_dispatch -
+                                             ((lpaddr_t)&x86_64_start_ap) +
+                                             X86_64_REAL_MODE_LINEAR_OFFSET);
+            *ap_dispatch = 1;
+            // end of time to update
+
             // interrupt state should be fine, as it's used directly from the
             // kcb.
             dispatch(next);
index c5e3a05..18fb44f 100644 (file)
@@ -508,7 +508,7 @@ static void  __attribute__ ((noreturn, noinline)) text_init(void)
 
 
     // do not remove/change this printf: needed by regression harness
-    printf("Barrelfish CPU driver starting on x86_64 apic_id %u\n", apic_id);
+    //printf("Barrelfish CPU driver starting on x86_64 apic_id %u\n", apic_id);
 
     if(apic_is_bsp()) {
         // Initialize classic (8259A) PIC
index c1c3fe8..54d98b8 100644 (file)
  * \cond
  */
 
-       .text
+        .text
         .align 4096
-       .code16
-       .org X86_64_REAL_MODE_OFFSET
+        .code16
+        .org X86_64_REAL_MODE_OFFSET
 
+// Start the 16bit real-mode code here
 
-//start the 16bit real-mode code here
-
-       .global x86_64_start_ap
+        .global x86_64_start_ap
 x86_64_start_ap:
         cli
-       mov $X86_64_REAL_MODE_SEGMENT,%ax
-       mov %ax,%ds
-       mov $(gdt_ptr - x86_64_start_ap),%si
-       lgdt (%si)
-        
+        mov $X86_64_REAL_MODE_SEGMENT,%ax
+        mov %ax,%ds
+        mov $(gdt_ptr - x86_64_start_ap),%si
+        lgdt (%si)
+
         // Work around for M5's limited support for protected
         // mode.  Once in protected mode it will treat instruction
         // fetches as if ES is the segment selector.  Therefore
@@ -60,120 +59,111 @@ x86_64_start_ap:
         mov $PROT_CS,%ax
         mov %ax,%es
 
-       mov %cr0,%eax
-       or $PROT_MODE_ENABLE,%al
-       mov %eax,%cr0
-//     jmp PROT_CS:start_ap_pm
-       .byte 0x66
-           .byte 0xea
-           .long start_ap_pm - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET
-           .word PROT_CS
+        mov %cr0,%eax
+        or $PROT_MODE_ENABLE,%al
+        mov %eax,%cr0
+//      jmp PROT_CS:start_ap_pm
+        .byte 0x66
+        .byte 0xea
+        .long start_ap_pm - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET
+        .word PROT_CS
 
 
-//start the 32bit protected-mode code here
+// Start the 32bit protected-mode code here
 
         .code32
 start_ap_pm:
         // set up data segment
-       mov $PROT_DS,%eax
-       mov %eax,%ds
+        mov $PROT_DS,%eax
+        mov %eax,%ds
 
         // acquire start-up lock
-       mov $(x86_64_init_ap_lock - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET),%esi
+        mov $(x86_64_init_ap_lock - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET),%esi
 start_ap_spin:
-       xor %ax,%ax
-       lock bts %ax,(%esi)
-       jc start_ap_spin
+        lock bts $0,(%esi)
+        jc start_ap_spin
 
         // set up stack
-       mov $PROT_DS,%eax
-       mov %eax,%ss
-       mov $(start_ap_stack - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET),%esp
-
-       // Fill the four page tables with identity map
-       // eax = page table index, ebx = page table entry
-       mov $0, %ecx
-       mov $PAGE_BITS, %ebx
+        mov $PROT_DS,%eax
+        mov %eax,%ss
+        mov $(start_ap_stack - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET),%esp
+
+        // Fill the four page tables with identity map
+        // eax = page table index, ebx = page table entry
+        mov $0, %ecx
+        mov $PAGE_BITS, %ebx // P, R/R, U/S & PS bit set
 rep_fill:
-       mov %ebx, init_ap_pdir - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET(%ecx)
-       movl $0, init_ap_pdir - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET + 4(%ecx)
-       add $0x200000, %ebx
-       add $8, %ecx
-       cmp $4096 * 4, %ecx
-       jne rep_fill
+        mov %ebx, init_ap_pdir - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET(%ecx)
+        movl $0, init_ap_pdir - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET + 4(%ecx)
+        add $0x200000, %ebx // 0x200000 is two megabytes
+        add $8, %ecx
+        cmp $4096 * 4, %ecx // 4*4096 / 8 = 2048, 2048*2 = 4GB
+        jne rep_fill
 
         // enable page address extension
         mov %cr4,%eax
-       or $PAE,%eax
-       mov %eax,%cr4
+        or $PAE,%eax
+        mov %eax,%cr4
 
         // set PML4 pointer to cr3. the right value is copied to the code
-       // here by start_aps_startall
-//     .global pml4_code_ptr
-//pml4_code_ptr:
-//     mov $0xffeeddcc,%eax
-       mov $(init_ap_pml4 - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET), %eax
-       mov %eax,%cr3
+        // here by start_aps_startall
+//      .global pml4_code_ptr
+// pml4_code_ptr:
+//      mov $0xffeeddcc,%eax
+        mov $(init_ap_pml4 - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET), %eax
+        mov %eax,%cr3
 
         // enable long-mode by setting EFER.LME
-       mov $MSR_IA32_EFER,%ecx
-       rdmsr
-       bts $LME,%eax
-       wrmsr
+        mov $MSR_IA32_EFER,%ecx
+        rdmsr
+        bts $LME,%eax
+        wrmsr
 
         // enable paging
-       mov %cr0,%eax
-       bts $PAGING_ENABLE,%eax
-       mov %eax,%cr0
+        mov %cr0,%eax
+        bts $PAGING_ENABLE,%eax
+        mov %eax,%cr0
 
         // jmp to long-mode to the linear address corresponding the
-       // real mode segment REAL_MODE_SEGMENT
-//     jmp LONG_MODE_CS:start_ap_64
+        // real mode segment REAL_MODE_SEGMENT
+        // jmp LONG_MODE_CS:start_ap_64
         .byte 0xea
-           .long start_ap_64 - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET
-           .word LONG_MODE_CS
-
-
-
-
+        .long start_ap_64 - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET
+        .word LONG_MODE_CS
 
-//start the 64bit long-mode code here
+// Start the 64bit long-mode code here
 
         .code64
 start_ap_64:
-       
-       // initialize bootup stack for the 64bit long mode
-       lea (start_ap_stack)(%rip), %rsp
-//        lea (kernel_stack + KERNEL_STACK_SIZE)(%rip), %rsp
+        // initialize bootup stack for the 64bit long mode
+        lea (start_ap_stack)(%rip), %rsp
+        // lea (kernel_stack + KERNEL_STACK_SIZE)(%rip), %rsp
 
-
-
-//we should not return here after the call, but for any case, use a call
-//instead of a jmp...
+        //we should not return here after the call, but for any case, use a call
+        //instead of a jmp...
 
         // jmp to the first C initialization function in the kernel
-       // the address is copied here to this code by start_aps_startall
-       // the jmp is a jmp to an absolute address. it is difficult to compute
-       // it here, because it is IP-relative and the IP here is
-       // REAL_MODE_LINEAR_OFFSET + some offset for _every_ AP to be started,
-       // independently of the final kernel location
+        // the address is copied here to this code by start_aps_startall
+        // the jmp is a jmp to an absolute address. it is difficult to compute
+        // it here, because it is IP-relative and the IP here is
+        // REAL_MODE_LINEAR_OFFSET + some offset for _every_ AP to be started,
+        // independently of the final kernel location
 
-       lea (x86_64_init_ap_global)(%rip),%rbx
-       mov (%rbx),%rbx
-       mov $KERNEL_BOOT_MAGIC,%rax
+        lea (x86_64_init_ap_global)(%rip),%rbx
+        mov (%rbx),%rbx
+        mov $KERNEL_BOOT_MAGIC,%rax
 
         lea (x86_64_init_ap_absolute_entry)(%rip),%rcx
-       mov (%rcx),%rcx
-       call *%rcx
+        mov (%rcx),%rcx
+        call *%rcx
 
-//we should never reach this location...
+// We should never reach this location...
 loop_ap:
         hlt
-       jmp loop_ap
+        jmp loop_ap
 
 
-//stack for 64bit mode
-
+// Stack for 64bit mode
         .align 16
         .fill BOOT_AP_KERNEL_SIZE,1,0
 start_ap_stack:
@@ -185,60 +175,63 @@ gdt:
         .byte 0xff,0xff,0x00,0x00,0x00,0x9a,0xaf,0x00 // 64bit code segment, D _cleared_ => "16bit"
         .byte 0xff,0xff,0x00,0x00,0x00,0x92,0xcf,0x00 // data
         .byte 0xff,0xff,0x00,0x00,0x00,0x9a,0xcf,0x00 // 32bit code segment for protected-mode
-       .byte 0xff,0xff,0x00,0x80,0x0b,0x92,0xff,0x00 // screen
+        .byte 0xff,0xff,0x00,0x80,0x0b,0x92,0xff,0x00 // screen
         .byte 0xff,0xff,0x00,0x60,0x00,0x9a,0xcf,0x00 // segment at linear address 0x6000
         .byte 0xff,0xff,0x00,0x00,0x00,0x92,0xaf,0x00 // stack segment in 64bit mode
 
 
 gdt_ptr:
         .word gdt_ptr - gdt
-       .long gdt - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET
-       .long 0
+        .long gdt - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET
+        .long 0
 
-       // 4GByte identity mapped page-table using 2MByte pages
-       .align X86_64_BASE_PAGE_SIZE
+        // 4GByte identity mapped page-table using 2MByte pages
+        .align X86_64_BASE_PAGE_SIZE
 init_ap_pml4:
-       .quad (init_ap_pdpt - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET) + TABLE_BITS
-       // Fill the rest with zeroes
-       .fill X86_64_BASE_PAGE_SIZE - (1 * 8), 1, 0
+        .quad (init_ap_pdpt - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET) + TABLE_BITS
+        // Fill the rest with zeroes
+        .fill X86_64_BASE_PAGE_SIZE - (1 * 8), 1, 0
 
-       .align X86_64_BASE_PAGE_SIZE
+        .align X86_64_BASE_PAGE_SIZE
 init_ap_pdpt:
-       .quad (init_ap_pdir  - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET) + TABLE_BITS
-       .quad (init_ap_pdir2 - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET) + TABLE_BITS
-       .quad (init_ap_pdir3 - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET) + TABLE_BITS
-       .quad (init_ap_pdir4 - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET) + TABLE_BITS
-       // Fill the rest with zeroes
-       .fill X86_64_BASE_PAGE_SIZE - (4 * 8), 1, 0
-
-       .align X86_64_BASE_PAGE_SIZE
+        .quad (init_ap_pdir  - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET) + TABLE_BITS
+        .quad (init_ap_pdir2 - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET) + TABLE_BITS
+        .quad (init_ap_pdir3 - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET) + TABLE_BITS
+        .quad (init_ap_pdir4 - x86_64_start_ap + X86_64_REAL_MODE_LINEAR_OFFSET) + TABLE_BITS
+        // Fill the rest with zeroes
+        .fill X86_64_BASE_PAGE_SIZE - (4 * 8), 1, 0
+
+        .align X86_64_BASE_PAGE_SIZE
 init_ap_pdir:
-       .fill X86_64_BASE_PAGE_SIZE, 1, 0
+        .fill X86_64_BASE_PAGE_SIZE, 1, 0
 
-       .align X86_64_BASE_PAGE_SIZE
+        .align X86_64_BASE_PAGE_SIZE
 init_ap_pdir2:
-       .fill X86_64_BASE_PAGE_SIZE, 1, 0
+        .fill X86_64_BASE_PAGE_SIZE, 1, 0
 
-       .align X86_64_BASE_PAGE_SIZE
+        .align X86_64_BASE_PAGE_SIZE
 init_ap_pdir3:
-       .fill X86_64_BASE_PAGE_SIZE, 1, 0
+        .fill X86_64_BASE_PAGE_SIZE, 1, 0
 
-       .align X86_64_BASE_PAGE_SIZE
+        .align X86_64_BASE_PAGE_SIZE
 init_ap_pdir4:
-       .fill X86_64_BASE_PAGE_SIZE, 1, 0
+        .fill X86_64_BASE_PAGE_SIZE, 1, 0
 
         // the absolute destination address to the first C function in the kernel.
-       // The address is copied to this variable by start_aps_startall.
-       .global x86_64_init_ap_absolute_entry
+        // The address is copied to this variable by start_aps_startall.
+        .global x86_64_init_ap_absolute_entry
 x86_64_init_ap_absolute_entry:
         .long 0
-       .long 0
+        .long 0
 
         .global x86_64_init_ap_global
 x86_64_init_ap_global:
         .long 0
-       .long 0
 
+        .global x86_64_init_ap_dispatch
+x86_64_init_ap_dispatch:
+        .long 0
+        .long 0
 
         .global x86_64_init_ap_wait
 x86_64_init_ap_wait:
index 672157c..50811b5 100644 (file)
@@ -548,10 +548,10 @@ struct sysret sys_suspend(bool do_halt)
     dcb_current->disabled = false;
 
     if (do_halt) {
-        printf("%s:%s:%d: before halt of core (%"PRIuCOREID")\n",
-               __FILE__, __FUNCTION__, __LINE__, my_core_id);
+        //printf("%s:%s:%d: before halt of core (%"PRIuCOREID")\n",
+        //       __FILE__, __FUNCTION__, __LINE__, my_core_id);
         halt();
-        printf("%s:%s:%d: woken up again...\n", __FILE__, __FUNCTION__, __LINE__);
+        //printf("%s:%s:%d: woken up again...\n", __FILE__, __FUNCTION__, __LINE__);
     } else {
         printk(LOG_NOTE, "in sys_suspend(<no_halt>)!\n");
         // switch to next
index 825a512..497d1d1 100644 (file)
         flounderBindings = ["intermon"],
         flounderExtraBindings = [],
         flounderTHCStubs = []
+    },
+
+    build application {
+        target = "x86bootbench",
+        cFiles = (find withSuffices [".c"]),
+        assemblyFiles = ["init_ap_x86_64.S"],
+        addCFlags = ["-DMICROBENCH", "-DUPDATE"],
+        addLibraries = libDeps ["vfs", "spawndomain", "elf", "acpi_client", "octopus", "bench"],
+        addIncludes = [
+            "../../../kernel/include/arch/x86_64/",
+            "../../../kernel/include"
+        ],
+        mackerelDevices = [],
+        flounderDefs = ["monitor_blocking", "monitor"],
+        flounderBindings = ["intermon"]
     }
 ]
\ No newline at end of file
index 992d68c..54d98b8 100644 (file)
@@ -227,8 +227,11 @@ x86_64_init_ap_absolute_entry:
         .global x86_64_init_ap_global
 x86_64_init_ap_global:
         .long 0
-        .long 0
 
+        .global x86_64_init_ap_dispatch
+x86_64_init_ap_dispatch:
+        .long 0
+        .long 0
 
         .global x86_64_init_ap_wait
 x86_64_init_ap_wait:
index 63944cd..5798aae 100644 (file)
@@ -78,7 +78,9 @@ extern uint64_t x86_64_init_ap_wait;
 extern uint64_t x86_64_init_ap_lock;
 extern uint64_t x86_64_start;
 extern uint64_t x86_64_init_ap_global;
+extern uint64_t x86_64_init_ap_dispatch;
 
+volatile uint32_t* ap_dispatch;
 static coreid_t my_arch_id;
 static struct capref kernel_cap;
 
@@ -223,6 +225,14 @@ int start_aps_x86_64_start(uint8_t core_id, genvaddr_t entry)
                                          ((lpaddr_t) &x86_64_start_ap) +
                                          real_dest);
 
+    // pointer to the pseudo-lock that is set before dispatch,
+    // to measure time it takes to update the kernel
+    ap_dispatch = (volatile uint32_t *)
+                   ((lpaddr_t) &x86_64_init_ap_dispatch -
+                   ((lpaddr_t) &x86_64_start_ap) +
+                    real_dest);
+    *ap_dispatch = 0;
+
     // Pointer to the lock variable in the realmode code
     volatile uint8_t *ap_lock = (volatile uint8_t *)
                                         ((lpaddr_t) &x86_64_init_ap_lock -
@@ -232,6 +242,7 @@ int start_aps_x86_64_start(uint8_t core_id, genvaddr_t entry)
     *ap_wait = AP_STARTING_UP;
 
 
+
     err = invoke_send_init_ipi(core_id);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "invoke send init ipi");
@@ -699,7 +710,6 @@ static void boot_core_reply(struct monitor_binding *st, errval_t msgerr)
         USER_PANIC_ERR(msgerr, "msgerr in boot_core_reply, exiting\n");
     }
     DEBUG("%s:%d: got boot_core_reply.\n", __FILE__, __LINE__);
-    end = bench_tsc();
 
     done = true;
 }
@@ -707,7 +717,6 @@ static void boot_core_reply(struct monitor_binding *st, errval_t msgerr)
 static void power_down_response(struct monitor_binding *st, coreid_t target)
 {
     DEBUG("%s:%s:%d: Got power_down_response. target=%"PRIuCOREID"\n", __FILE__, __FUNCTION__, __LINE__, target);
-    end = bench_tsc();
 
     done = true;
 }
@@ -805,10 +814,94 @@ static void mysleep(int sleeptime)
     }
 }
 
-int main(int argc, char** argv)
-{
+#if defined(MICROBENCH)
+static int real_main(int argc, char** argv);
+int main(int argc, char** argv) {
+    errval_t err;
+
+    vfs_init();
+
     bench_arch_init();
 
+    err = connect_to_acpi();
+    if (err_is_fail(err)) {
+        USER_PANIC_ERR(err, "connect to acpi failed.");
+    }
+
+    err = oct_init();
+    if (err_is_fail(err)) {
+        USER_PANIC_ERR(err, "Octopus initialization failed.");
+    }
+
+#if UPDOWN
+    int argc_down = 4;
+    char* argv_down[] = {
+        "x86boot",
+        "auto",
+        "down",
+        "1"
+    };
+    int argc_up = 4;
+    char* argv_up[] = {
+        "x86boot",
+        "auto",
+        "up",
+        "1"
+    };
+
+    uint64_t start_down, end_down, start_up, end_up;
+
+    printf("# ticks-down ms-down ticks-up ms-up\n");
+    for (size_t i=0; i<20; i++) {
+        start_down = bench_tsc();
+        real_main(argc_down, argv_down);
+        end_down = bench_tsc();
+
+        start_up = bench_tsc();
+        real_main(argc_up, argv_up);
+        end_up = bench_tsc();
+
+        printf("%lu %lu %lu %lu\n",
+               end_down-start_down, bench_tsc_to_ms(end_down-start_down),
+               end_up-start_up, bench_tsc_to_ms(end_up-start_up));
+
+    }
+#endif
+
+#if UPDATE
+    int argc_update = 4;
+    char* argv_update[] = {
+        "x86boot",
+        "auto",
+        "update",
+        "1"
+    };
+    uint64_t start_up, end_up;
+
+    printf("# ticks-update ms-update\n");
+    for (size_t i=0; i<20; i++) {
+
+        start_up = bench_tsc();
+        real_main(argc_update, argv_update);
+        end_up = bench_tsc();
+
+        printf("%lu %lu\n",
+               end_up-start_up, bench_tsc_to_ms(end_up-start_up));
+
+    }
+#endif
+
+
+
+}
+#endif
+
+#if !defined(MICROBENCH)
+int main(int argc, char** argv)
+#else
+static int real_main(int argc, char** argv)
+#endif
+{
     errval_t err;
     for (size_t i = 0; i < argc; i++) {
         DEBUG("%s:%s:%d: argv[i]=%s\n",
@@ -819,17 +912,27 @@ int main(int argc, char** argv)
         return 1;
     }
 
+#if !defined(MICROBENCH)
     vfs_init();
 
-    struct monitor_binding *st = get_monitor_binding();
-    st->rx_vtbl.boot_core_reply = boot_core_reply;
-    st->rx_vtbl.power_down_response = power_down_response;
+    bench_arch_init();
 
     err = connect_to_acpi();
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "connect to acpi failed.");
     }
 
+    err = oct_init();
+    if (err_is_fail(err)) {
+        USER_PANIC_ERR(err, "Octopus initialization failed.");
+    }
+#endif
+
+    struct monitor_binding *st = get_monitor_binding();
+    st->rx_vtbl.boot_core_reply = boot_core_reply;
+    st->rx_vtbl.power_down_response = power_down_response;
+
+
     struct monitor_blocking_rpc_client *mc = get_monitor_blocking_rpc_client();
     err = mc->vtbl.get_arch_core_id(mc, (uintptr_t*)&my_arch_id);
     if (err_is_fail(err)) {
@@ -846,15 +949,9 @@ int main(int argc, char** argv)
         DEBUG("%s:%d: argv[i]=%s\n", __FILE__, __LINE__, argv[i]);
     }
 
-    start = bench_tsc();
-
     coreid_t target_id = (coreid_t) atoi(argv[3]);
     assert(target_id < MAX_COREID);
 
-    err = oct_init();
-    if (err_is_fail(err)) {
-        USER_PANIC_ERR(err, "Octopus initialization failed.");
-    }
 
     err = create_or_get_kcb_cap(target_id);
     if (err_is_fail(err)) {
@@ -864,7 +961,7 @@ int main(int argc, char** argv)
     //enum cpu_type type = (enum cpu_type) atoi(argv[4]);
     //assert(type < CPU_TYPE_NUM);
 
-    if (!strncmp(argv[2], "up", 2)) {
+    if (!strcmp(argv[2], "up")) {
         char sched[32] = { 0 };
         if ((strlen(argv[2]) > 3) && argv[2][2] == '=') {
              char *s=argv[2]+3;
@@ -898,13 +995,46 @@ int main(int argc, char** argv)
         }
 
         err = spawn_xcore_monitor(target_id, target_id, CPU_X86_64, sched,
-                                  "loglevel=4 logmask=255", urpc_frame_id);
+                                  "loglevel=0 logmask=0", urpc_frame_id);
+        if (err_is_fail(err)) {
+            USER_PANIC_ERR(err, "spawn xcore monitor failed.");
+        }
+    }
+    else if (!strcmp(argv[2], "update")) {
+        char sched[32] = { 0 };
+        if ((strlen(argv[2]) > 3) && argv[2][2] == '=') {
+             char *s=argv[2]+3;
+             int i;
+             for (i = 0; i < 31; i++) {
+                 if (!s[i] || s[i] == ' ') {
+                     break;
+                 }
+             }
+             memcpy(sched, s, i);
+             sched[i] = 0;
+        }
+
+        struct capref frame;
+        size_t framesize;
+        struct frame_identity urpc_frame_id;
+        err = frame_alloc_identify(&frame, MON_URPC_SIZE, &framesize, &urpc_frame_id);
+        if (err_is_fail(err)) {
+            USER_PANIC_ERR(err, "frame_alloc_identify failed.");
+        }
+        err = cap_mark_remote(frame);
+        if (err_is_fail(err)) {
+            DEBUG_ERR(err, "Can not mark cap remote.");
+            return err;
+        }
+
+        done = true;
+        err = spawn_xcore_monitor(target_id, target_id, CPU_X86_64, sched,
+                                  "loglevel=0 logmask=0", urpc_frame_id);
         if (err_is_fail(err)) {
             USER_PANIC_ERR(err, "spawn xcore monitor failed.");
         }
-        end = bench_tsc();
-        debug_printf("%s:%s:%d: Time it took for x86boot portion [ticks]: %lu [ms]: %lu\n",
-               __FILE__, __FUNCTION__, __LINE__, end-start, bench_tsc_to_ms(end-start));
+
+        while(*ap_dispatch != 1);
     }
     else if (!strcmp(argv[2], "down")) {
         DEBUG("%s:%d: Power it down...\n", __FILE__, __LINE__);
@@ -1012,9 +1142,6 @@ int main(int argc, char** argv)
         if (err_is_fail(err)) {
             USER_PANIC_ERR(err, "spawn xcore monitor failed.");
         }
-        end = bench_tsc();
-        debug_printf("%s:%s:%d: Time it took for x86boot portion [ticks]: %lu [ms]: %lu\n",
-               __FILE__, __FUNCTION__, __LINE__, end-start, bench_tsc_to_ms(end-start));
     }
     else if (!strcmp(argv[2], "resume")) {
         DEBUG("%s:%s:%d: Resume...\n", __FILE__, __FUNCTION__, __LINE__);
@@ -1040,9 +1167,5 @@ int main(int argc, char** argv)
     }
 
     DEBUG("%s:%s:%d: We're done here...\n", __FILE__, __FUNCTION__, __LINE__);
-
-    debug_printf("%s:%s:%d: Time it took [ticks]: %lu [ms]: %lu\n",
-           __FILE__, __FUNCTION__, __LINE__, end-start, bench_tsc_to_ms(end-start));
-
     return 0;
 }
index 8990f12..5393520 100644 (file)
@@ -131,14 +131,14 @@ static void monitor_initialized(struct intermon_binding *b)
     struct intermon_state *st = b->st;
     errval_t err = SYS_ERR_OK;
 
-    printf("%s:%s:%d: \n", __FILE__, __FUNCTION__, __LINE__);
+    //printf("%s:%s:%d: \n", __FILE__, __FUNCTION__, __LINE__);
     // Inform other monitors of this new monitor
     monitor_ready[st->core_id] = true;
     err = new_monitor_notify(st->core_id);
     if (err_is_fail(err)) {
         err = err_push(err, MON_ERR_INTERN_NEW_MONITOR);
     }
-    printf("%s:%s:%d: \n", __FILE__, __FUNCTION__, __LINE__);
+    //printf("%s:%s:%d: \n", __FILE__, __FUNCTION__, __LINE__);
 
     // New plan, do timing sync for every time a monitor has come up...
     /*if(num_monitors > 1) {
index 7499996..81a5bac 100644 (file)
@@ -519,7 +519,7 @@ static void get_arch_core_id(struct monitor_blocking_binding *b)
 {
     static uintptr_t arch_id = -1;
     errval_t err;
-    printf("%s:%s:%d: \n", __FILE__, __FUNCTION__, __LINE__);
+//    printf("%s:%s:%d: \n", __FILE__, __FUNCTION__, __LINE__);
 
     if (arch_id == -1) {
         err = invoke_monitor_get_arch_id(&arch_id);
index 0564de8..74ab7b9 100644 (file)
@@ -962,7 +962,7 @@ struct monitor_binding* cpuboot_driver;
 static void power_down_request(struct monitor_binding *b,
                                coreid_t target)
 {
-   printf("%s:%d\n", __FUNCTION__, __LINE__);
+   //printf("%s:%d\n", __FUNCTION__, __LINE__);
    errval_t err;
 
    cpuboot_driver = b;
index c0410e4..1b16fd8 100644 (file)
@@ -12,9 +12,9 @@ int main(int argc, char *argv[])
         uint64_t start = bench_tsc();
         for (volatile int i = 0; i < ITERATIONS; i++);
         uint64_t end = bench_tsc();
-        debug_printf("Time for loop-iteration: %"PRIu64" ticks / %"PRIu64" ms\n",
+        printf("Time for loop-iteration: %"PRIu64" ticks / %"PRIu64" ms\n",
                end-start, bench_tsc_to_ms(end-start));
-        struct monitor_blocking_rpc_client *mc = get_monitor_blocking_rpc_client();
+        /*struct monitor_blocking_rpc_client *mc = get_monitor_blocking_rpc_client();
 
         uintptr_t id;
         errval_t err = mc->vtbl.get_arch_core_id(mc, &id);
@@ -24,7 +24,7 @@ int main(int argc, char *argv[])
         else{
             printf("%s:%s:%d: core_id = %lu\n",
                    __FILE__, __FUNCTION__, __LINE__, id);
-        }
+        }*/
     }
 
   return EXIT_SUCCESS;