Index: boot/Makefile.common =================================================================== --- boot/Makefile.common (revision bdfd3c978d7f3378bdc591ff4fe153a17d5c2ea3) +++ boot/Makefile.common (revision 95319bd04e17f7e1bb127fdbbfb754cd00dda2b6) @@ -73,5 +73,6 @@ $(USPACEDIR)/app/ps/ps \ $(USPACEDIR)/app/top/top \ - $(USPACEDIR)/app/uptime/uptime + $(USPACEDIR)/app/uptime/uptime \ + $(USPACEDIR)/app/dummy_load/dummy_load COMPONENTS = \ Index: kernel/generic/src/ipc/ipc.c =================================================================== --- kernel/generic/src/ipc/ipc.c (revision bdfd3c978d7f3378bdc591ff4fe153a17d5c2ea3) +++ kernel/generic/src/ipc/ipc.c (revision 95319bd04e17f7e1bb127fdbbfb754cd00dda2b6) @@ -219,4 +219,5 @@ bool do_lock = ((!selflocked) || callerbox != (&TASK->answerbox)); + /* Count sent answer */ spinlock_lock(&TASK->lock); TASK->ipc_info.answer_sent++; @@ -280,4 +281,5 @@ static void _ipc_call(phone_t *phone, answerbox_t *box, call_t *call) { + /* Count sent ipc call */ spinlock_lock(&TASK->lock); TASK->ipc_info.call_sent++; @@ -384,4 +386,5 @@ int ipc_forward(call_t *call, phone_t *newphone, answerbox_t *oldbox, int mode) { + /* Count forwarded calls */ spinlock_lock(&TASK->lock); TASK->ipc_info.forwarded++; @@ -429,4 +432,5 @@ if (!list_empty(&box->irq_notifs)) { + /* Count recieved IRQ notification */ spinlock_lock(&TASK->lock); TASK->ipc_info.irq_notif_recieved++; @@ -442,4 +446,5 @@ interrupts_restore(ipl); } else if (!list_empty(&box->answers)) { + /* Count recieved answer */ spinlock_lock(&TASK->lock); TASK->ipc_info.answer_recieved++; @@ -451,5 +456,5 @@ atomic_dec(&request->data.phone->active_calls); } else if (!list_empty(&box->calls)) { - + /* Count recieved call */ spinlock_lock(&TASK->lock); TASK->ipc_info.call_recieved++; Index: uspace/Makefile =================================================================== --- uspace/Makefile (revision bdfd3c978d7f3378bdc591ff4fe153a17d5c2ea3) +++ uspace/Makefile (revision 95319bd04e17f7e1bb127fdbbfb754cd00dda2b6) @@ -48,4 +48,5 @@ app/top \ app/uptime \ + app/dummy_load \ srv/clip \ srv/devmap \ Index: uspace/app/dummy_load/Makefile =================================================================== --- uspace/app/dummy_load/Makefile (revision 95319bd04e17f7e1bb127fdbbfb754cd00dda2b6) +++ uspace/app/dummy_load/Makefile (revision 95319bd04e17f7e1bb127fdbbfb754cd00dda2b6) @@ -0,0 +1,37 @@ +# +# Copyright (c) 2005 Martin Decky +# Copyright (c) 2007 Jakub Jermar +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +BINARY = dummy_load + +SOURCES = \ + dummy_load.c \ + input.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/app/dummy_load/dummy_load.c =================================================================== --- uspace/app/dummy_load/dummy_load.c (revision 95319bd04e17f7e1bb127fdbbfb754cd00dda2b6) +++ uspace/app/dummy_load/dummy_load.c (revision 95319bd04e17f7e1bb127fdbbfb754cd00dda2b6) @@ -0,0 +1,166 @@ +/* + * Copyright (c) 2010 Stanislav Kozina + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup dummy_load + * @brief Dummy application to make some system load. + * @{ + */ +/** + * @file + */ + +#include +#include +#include +#include +#include +#include +#include "input.h" + +#define TASK_COUNT 50 +#define USPACE_CYCLES (1 << 26) +#define SYSTEM_CYCLES (1 << 16) + +static void uspace_load() +{ + puts("u"); + uint64_t volatile i; + for (i = 0; i < USPACE_CYCLES; ++i) + ; +} + +static int task_count; + +static void system_init() +{ + task_count = TASK_COUNT; + task_id_t *tasks = malloc(task_count * sizeof(task_id_t)); + int result = get_task_ids(tasks, sizeof(task_id_t) * task_count); + + while (result > task_count) { + task_count *= 2; + tasks = realloc(tasks, task_count * sizeof(task_id_t)); + result = get_task_ids(tasks, sizeof(task_id_t) * task_count); + } + + free(tasks); +} + +static void system_load() +{ + puts("s"); + task_id_t *tasks = malloc(task_count * sizeof(task_id_t)); + int result; + + uint64_t i; + for (i = 0; i < SYSTEM_CYCLES; ++i) { + result = get_task_ids(tasks, sizeof(task_id_t) * task_count); + } + + free(tasks); +} + +static void usage() +{ + printf("Usage: dummy_load [-u|-s|-r]\n"); +} + +int main(int argc, char *argv[]) +{ + --argc; ++argv; + system_init(); + + char mode = 'r'; + if (argc > 1) { + printf("Bad argument count!\n"); + usage(); + exit(1); + } + + if (argc > 0) { + if (str_cmp(*argv, "-r") == 0) { + printf("Doing random load\n"); + mode = 'r'; + } else if (str_cmp(*argv, "-u") == 0) { + printf("Doing uspace load\n"); + mode = 'u'; + } else if (str_cmp(*argv, "-s") == 0) { + printf("Doing system load\n"); + mode = 's'; + } else { + usage(); + exit(1); + } + } else { + mode = 'r'; + printf("Doing random load\n"); + } + + bool system = false; + while (true) { + char c = tgetchar(0); + switch (c) { + case 'r': + mode = 'r'; + break; + case 'u': + mode = 'u'; + break; + case 's': + mode = 's'; + break; + case 'q': + exit(0); + break; + } + switch (mode) { + case 'r': + if (system) { + system_load(); + } else { + uspace_load(); + } + system = !system; + break; + case 'u': + uspace_load(); + break; + case 's': + system_load(); + break; + } + fflush(stdout); + } + + puts("\n"); + fflush(stdout); + return 0; +} + +/** @} + */ Index: uspace/app/dummy_load/input.c =================================================================== --- uspace/app/dummy_load/input.c (revision 95319bd04e17f7e1bb127fdbbfb754cd00dda2b6) +++ uspace/app/dummy_load/input.c (revision 95319bd04e17f7e1bb127fdbbfb754cd00dda2b6) @@ -0,0 +1,200 @@ +/* $OpenBSD: input.c,v 1.12 2005/04/13 02:33:08 deraadt Exp $ */ +/* $NetBSD: input.c,v 1.3 1996/02/06 22:47:33 jtc Exp $ */ + +/*- + * Copyright (c) 1992, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek and Darren F. Provine. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)input.c 8.1 (Berkeley) 5/31/93 + */ + +/** @addtogroup dummy_load + * @{ + */ +/** @file + */ + +/* + * Top input. + */ + +#include +#include +#include + +#include +#include +#include +#include + +#include "input.h" + +#include +#include +#include +#include + +#define USEC_COUNT 1000000 + +/* return true iff the given timeval is positive */ +#define TV_POS(tv) \ + ((tv)->tv_sec > 0 || ((tv)->tv_sec == 0 && (tv)->tv_usec > 0)) + +/* subtract timeval `sub' from `res' */ +#define TV_SUB(res, sub) \ + (res)->tv_sec -= (sub)->tv_sec; \ + (res)->tv_usec -= (sub)->tv_usec; \ + if ((res)->tv_usec < 0) { \ + (res)->tv_usec += 1000000; \ + (res)->tv_sec--; \ + } + +/* We will use a hack here - if lastchar is non-zero, it is + * the last character read. We will somehow simulate the select + * semantics. + */ +static aid_t getchar_inprog = 0; +static char lastchar = '\0'; + +/* + * Do a `read wait': select for reading from stdin, with timeout *tvp. + * On return, modify *tvp to reflect the amount of time spent waiting. + * It will be positive only if input appeared before the time ran out; + * otherwise it will be zero or perhaps negative. + * + * If tvp is nil, wait forever, but return if select is interrupted. + * + * Return 0 => no input, 1 => can read() from stdin + * + */ +int rwait(struct timeval *tvp) +{ + struct timeval starttv, endtv, *s; + static ipc_call_t charcall; + ipcarg_t rc; + + /* + * Someday, select() will do this for us. + * Just in case that day is now, and no one has + * changed this, we use a temporary. + */ + if (tvp) { + (void) gettimeofday(&starttv, NULL); + endtv = *tvp; + s = &endtv; + } else + s = NULL; + + if (!lastchar) { +again: + if (!getchar_inprog) { + getchar_inprog = async_send_0(fphone(stdin), + CONSOLE_GET_EVENT, &charcall); + } + + if (!s) + async_wait_for(getchar_inprog, &rc); + else if (async_wait_timeout(getchar_inprog, &rc, s->tv_usec) == ETIMEOUT) { + tvp->tv_sec = 0; + tvp->tv_usec = 0; + return (0); + } + + getchar_inprog = 0; + if (rc) { + printf("End of file, bug?\n"); + exit(1); + } + + if (IPC_GET_ARG1(charcall) == KEY_RELEASE) + goto again; + + lastchar = IPC_GET_ARG4(charcall); + } + + if (tvp) { + /* since there is input, we may not have timed out */ + (void) gettimeofday(&endtv, NULL); + TV_SUB(&endtv, &starttv); + TV_SUB(tvp, &endtv); /* adjust *tvp by elapsed time */ + } + + return 1; +} + +/* + * `sleep' for the current turn time (using select). + * Eat any input that might be available. + */ +void tsleep(unsigned int sec) +{ + struct timeval tv; + + tv.tv_sec = 0; + tv.tv_usec = sec * USEC_COUNT; + while (TV_POS(&tv)) + if (rwait(&tv)) { + lastchar = '\0'; + } else + break; +} + +/* + * getchar with timeout. + */ +int tgetchar(unsigned int sec) +{ + static struct timeval timeleft; + char c; + + /* + * Reset timeleft to USEC_COUNT whenever it is not positive. + * In any case, wait to see if there is any input. If so, + * take it, and update timeleft so that the next call to + * tgetchar() will not wait as long. If there is no input, + * make timeleft zero or negative, and return -1. + * + * Most of the hard work is done by rwait(). + */ + if (!TV_POS(&timeleft)) { + timeleft.tv_sec = 0; + timeleft.tv_usec = sec * USEC_COUNT; + } + + if (!rwait(&timeleft)) + return -1; + + c = lastchar; + lastchar = '\0'; + return ((int) (unsigned char) c); +} + +/** @} + */ Index: uspace/app/dummy_load/input.h =================================================================== --- uspace/app/dummy_load/input.h (revision 95319bd04e17f7e1bb127fdbbfb754cd00dda2b6) +++ uspace/app/dummy_load/input.h (revision 95319bd04e17f7e1bb127fdbbfb754cd00dda2b6) @@ -0,0 +1,56 @@ +/* $OpenBSD: input.h,v 1.5 2003/06/03 03:01:41 millert Exp $ */ +/* $NetBSD: input.h,v 1.2 1995/04/22 07:42:36 cgd Exp $ */ + +/*- + * Copyright (c) 1992, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek and Darren F. Provine. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)input.h 8.1 (Berkeley) 5/31/93 + */ + +/** @addtogroup dummy_load + * @{ + */ +/** @file + */ + +#ifndef TOP_INPUT_ +#define TOP_INPUT_ + +#include + +extern int rwait(struct timeval *); +extern int tgetchar(unsigned int sec); +extern void tsleep(unsigned int sec); + +#endif + +/** @} + */