/*
* performance evaluation routine
*/
void
perf_eval(uint_t n)
{
uint_t i, j;
init_hist(1, MAX_TIME, histarea1);
for (i = 0; i < NO_MEASURE; i++) {
ini_flg(FLG1);
for (j = 0; j < n; j++) {
act_tsk(task_list[j]);
}
chg_pri(TSK_SELF, MAIN_PRIORITY_LOW);
/* let the task in the waiting queue of the event flag */
chg_pri(TSK_SELF, TPRI_INI);
begin_measure(1);
set_flg(FLG1, 0x01U);
end_measure(1);
chg_pri(TSK_SELF, MAIN_PRIORITY_LOW);
/* wait the task exits */
chg_pri(TSK_SELF, TPRI_INI);
}
syslog_1(LOG_NOTICE, "Execution times of set_flg"
" when %d tasks are released from waiting.", n);
print_hist(1);
syslog_flush();
}
/*
* performance evaluation routine
*/
void
perf_eval(uint_t n)
{
uint_t i;
intptr_t data;
PRI pri;
ini_pdq(PDQ1);
init_hist(1, MAX_TIME, histarea1);
for (i = 0; i < n; i++) {
data = i;
snd_pdq(PDQ1, data, 1);
}
for (i = 0; i < NO_MEASURE; i++) {
data = i;
begin_measure(1);
snd_pdq(PDQ1, data, 2);
end_measure(1);
rcv_pdq(PDQ1, &data, &pri);
}
syslog_1(LOG_NOTICE, "Execution times of snd_pdq"
" when %d data are queued.", n);
print_hist(1);
syslog_flush();
}
static void _up_assert(int errorcode)
{
/* Flush any buffered SYSLOG data */
(void)syslog_flush();
/* Are we in an interrupt handler or the idle task? */
if (g_current_regs || this_task()->pid == 0)
{
(void)up_irq_save();
for (; ; )
{
#if CONFIG_BOARD_RESET_ON_ASSERT >= 1
board_reset(0);
#endif
#ifdef CONFIG_ARCH_LEDS
board_autoled_on(LED_PANIC);
up_mdelay(250);
board_autoled_off(LED_PANIC);
up_mdelay(250);
#endif
}
}
else
{
#if CONFIG_BOARD_RESET_ON_ASSERT >= 2
board_reset(0);
#endif
exit(errorcode);
}
}
/*
* テストプログラムの終了
*/
void
test_finish(void)
{
SIL_PRE_LOC;
SIL_LOC_INT();
syslog_flush();
ext_ker();
}
void up_assert(const uint8_t *filename, int lineno)
{
#if CONFIG_TASK_NAME_SIZE > 0 && defined(CONFIG_DEBUG_ALERT)
struct tcb_s *rtcb = this_task();
#endif
board_autoled_on(LED_ASSERTION);
/* Flush any buffered SYSLOG data (from prior to the assertion) */
(void)syslog_flush();
#if CONFIG_TASK_NAME_SIZE > 0
_alert("Assertion failed at file:%s line: %d task: %s\n",
filename, lineno, rtcb->name);
#else
_alert("Assertion failed at file:%s line: %d\n",
filename, lineno);
#endif
up_dumpstate();
/* Flush any buffered SYSLOG data (from the above) */
(void)syslog_flush();
#ifdef CONFIG_ARCH_USBDUMP
/* Dump USB trace data */
(void)usbtrace_enumerate(assert_tracecallback, NULL);
#endif
#ifdef CONFIG_BOARD_CRASHDUMP
board_crashdump(up_getsp(), this_task(), filename, lineno);
#endif
_up_assert(EXIT_FAILURE);
}
/*
* 実行時間分布計測の表示
*/
void
print_hist(ID histid)
{
HISTCB *p_histcb;
uint_t i;
assert(TMIN_HISTID <= histid && histid <= TMAX_HISTID);
p_histcb = &(histcb_table[histid - TMIN_HISTID]);
for (i = 0; i <= p_histcb->maxval; i++) {
if (p_histcb->histarea[i] > 0) {
syslog_2(LOG_NOTICE, "%d : %d", i, p_histcb->histarea[i]);
syslog_flush();
}
}
if (p_histcb->over > 0) {
syslog_2(LOG_NOTICE, "> %d : %d", p_histcb->maxval, p_histcb->over);
}
if (p_histcb->under > 0) {
syslog_1(LOG_NOTICE, "> INT_MAX : %d", p_histcb->under);
}
syslog_flush();
}
static void
test_empty(void)
{
SYSTIM stime, etime;
volatile ulong_t i;
get_tim(&stime);
for (i = 0; i < NO_LOOP; i++) {
}
get_tim(&etime);
empty_time = etime - stime;
syslog(LOG_NOTICE, "empty loop: %u", empty_time);
syslog_flush();
}
/*
* main task (high priority)
*/
void main_task(intptr_t exinf)
{
syslog_0(LOG_NOTICE, "Performance evaluation program (3)");
syslog_flush();
perf_eval(0);
perf_eval(1);
perf_eval(2);
perf_eval(3);
perf_eval(4);
perf_eval(5);
perf_eval(10);
perf_eval(20);
test_finish();
}
static void
test_dly_nse(ulong_t dlytim)
{
SYSTIM stime, etime, delay_time;
volatile ulong_t i;
get_tim(&stime);
for (i = 0; i < NO_LOOP; i++) {
sil_dly_nse(dlytim);
}
get_tim(&etime);
delay_time = (etime - stime) - empty_time;
syslog(LOG_NOTICE, "sil_dly_nse(%u): %u %s", (uint_t)(dlytim),
(uint_t)(delay_time), delay_time > dlytim ? "OK" : "NG");
syslog_flush();
}
/*
* main task (low priority)
*/
void main_task(intptr_t exinf)
{
syslog_0(LOG_NOTICE, "Performance evaluation program (1)");
init_hist(1, MAX_TIME, histarea1);
init_hist(2, MAX_TIME, histarea2);
syslog_flush();
act_tsk(TASK1);
act_tsk(TASK2);
syslog_0(LOG_NOTICE, "Execution times of wup_tsk -> slp_tsk");
print_hist(1);
syslog_0(LOG_NOTICE, "Execution times of slp_tsk -> wup_tsk");
print_hist(2);
test_finish();
}
/*
* main task
*/
void main_task(intptr_t exinf)
{
uint_t i;
syslog_0(LOG_NOTICE, "Performance evaluation program (0)");
init_hist(1, MAX_TIME, histarea1);
syslog_flush();
for (i = 0; i < NO_MEASURE; i++) {
begin_measure(1);
end_measure(1);
}
syslog_0(LOG_NOTICE, "Measurement overhead");
print_hist(1);
test_finish();
}
int syslog_putc(int ch)
{
ssize_t nbytes;
uint8_t uch;
int errcode;
int ret;
/* Ignore any output:
*
* (1) Before the SYSLOG device has been initialized. This could happen
* from debug output that occurs early in the boot sequence before
* syslog_initialize() is called (SYSLOG_UNINITIALIZED).
* (2) While the device is being initialized. The case could happen if
* debug output is generated while syslog_initialize() executes
* (SYSLOG_INITIALIZING).
* (3) While we are generating SYSLOG output. The case could happen if
* debug output is generated while syslog_putc() executes
* (This case is actually handled inside of syslog_semtake()).
* (4) Any debug output generated from interrupt handlers. A disadvantage
* of using the generic character device for the SYSLOG is that it
* cannot handle debug output generated from interrupt level handlers.
* (5) Any debug output generated from the IDLE loop. The character
* driver interface is blocking and the IDLE thread is not permitted
* to block.
* (6) If an irrecoverable failure occurred during initialization. In
* this case, we won't ever bother to try again (ever).
*
* NOTE: That the third case is different. It applies only to the thread
* that currently holds the sl_sem sempaphore. Other threads should wait.
* that is why that case is handled in syslog_semtake().
*/
/* Cases (4) and (5) */
if (up_interrupt_context() || getpid() == 0)
{
errcode = ENOSYS;
goto errout_with_errcode;
}
/* We can save checks in the usual case: That after the SYSLOG device
* has been successfully opened.
*/
if (g_sysdev.sl_state != SYSLOG_OPENED)
{
/* Case (1) and (2) */
if (g_sysdev.sl_state == SYSLOG_UNINITIALIZED ||
g_sysdev.sl_state == SYSLOG_INITIALIZING)
{
errcode = EAGAIN; /* Can't access the SYSLOG now... maybe next time? */
goto errout_with_errcode;
}
/* Case (6) */
if (g_sysdev.sl_state == SYSLOG_FAILURE)
{
errcode = ENXIO; /* There is no SYSLOG device */
goto errout_with_errcode;
}
/* syslog_initialize() is called as soon as enough of the operating
* system is in place to support the open operation... but it is
* possible that the SYSLOG device is not yet registered at that time.
* In this case, we know that the system is sufficiently initialized
* to support an attempt to re-open the SYSLOG device.
*
* NOTE that the scheduler is locked. That is because we do not have
* fully initialized semaphore capability until the SYSLOG device is
* successfully initialized
*/
sched_lock();
if (g_sysdev.sl_state == SYSLOG_REOPEN)
{
/* Try again to initialize the device. We may do this repeatedly
* because the log device might be something that was not ready
* the first time that syslog_initializee() was called (such as a
* USB serial device that has not yet been connected or a file in
* an NFS mounted file system that has not yet been mounted).
*/
ret = syslog_initialize();
if (ret < 0)
{
sched_unlock();
errcode = -ret;
goto errout_with_errcode;
}
}
sched_unlock();
DEBUGASSERT(g_sysdev.sl_state == SYSLOG_OPENED);
}
/* Ignore carriage returns */
if (ch == '\r')
{
return ch;
}
/* The syslog device is ready for writing and we have something of
* value to write.
*/
ret = syslog_takesem();
if (ret < 0)
{
/* We probably already hold the semaphore and were probably
* re-entered by the logic kicked off by syslog_write().
* We might also have been interrupted by a signal. Either
* way, we are outta here.
*/
errcode = -ret;
goto errout_with_errcode;
}
/* Pre-pend a newline with a carriage return. */
if (ch == '\n')
{
/* Write the CR-LF sequence */
nbytes = syslog_write(g_syscrlf, 2);
/* Synchronize the file when each CR-LF is encountered (i.e.,
* implements line buffering always).
*/
#ifndef CONFIG_DISABLE_MOUNTPOINT
if (nbytes > 0)
{
syslog_flush();
}
#endif
}
else
{
/* Write the non-newline character (and don't flush) */
uch = (uint8_t)ch;
nbytes = syslog_write(&uch, 1);
}
syslog_givesem();
/* Check if the write was successful. If not, nbytes will be
* a negated errno value.
*/
if (nbytes < 0)
{
errcode = -ret;
goto errout_with_errcode;
}
return ch;
errout_with_errcode:
set_errno(errcode);
return EOF;
}