OS_PROCESS void TProc1::exec()
{
for(;;)
{
sleep(10);
green_led::On();
event.signal();
// waste time (2x Proc0)
waste_time();
waste_time();
}
}
void *thread_func_1(void *ptr){
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(0, &mask);
if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) <0)perror("pthread_setaffinity_np");
printf("Policzylem %f na CPU %d\n", waste_time(10000), sched_getcpu());
CPU_ZERO(&mask);
CPU_SET(1, &mask);
if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) <0)perror("pthread_setaffinity_np");
printf("Policzylem %f na CPU %d\n", waste_time(10000), sched_getcpu());
return NULL;
}
init_fn() {
int i, j, stat;
printf("Created init function: ");
printf("pid %d / niceval: %d\n",current->pid, current->stat_prio);
sched_waitq_init(&wq1);
sched_waitq_init(&wq2);
// Parent process forks 9 CPU-bound processes
for (i=1; i<10; i++) {
switch(sched_fork()) {
case -1:
fprintf(stderr,"Fork failed in pid %d\n",current->pid);
return -1;
break;
case 0:
sched_nice(20+i*2);
child_fn();
sched_exit(0);
break;
}
}
// Parent process waits for a long time before it
// does its own CPU-bound operations
kill(getpid(),SIGABRT);
for (;;) {
for (i=0; i<40; i++)
sched_sleep(&wq1);
kill(getpid(),SIGABRT);
waste_time(10);
kill(getpid(),SIGABRT);
}
}
/*
* wear:
* The player wants to wear something, so let him/her put it on.
*/
void
wear()
{
register THING *obj;
register char *sp;
if ((obj = get_item("wear", ARMOR)) == NULL)
return;
if (cur_armor != NULL)
{
addmsg("you are already wearing some");
if (!terse)
addmsg(". You'll have to take it off first");
endmsg();
after = FALSE;
return;
}
if (obj->o_type != ARMOR)
{
msg("you can't wear that");
return;
}
waste_time();
obj->o_flags |= ISKNOW;
sp = inv_name(obj, TRUE);
cur_armor = obj;
if (!terse)
addmsg("you are now ");
msg("wearing %s", sp);
}
void test_task
(
uint_32 initial_data
)
{
MQX_TICK_STRUCT ticks;
_mqx_uint result;
_mqx_uint n;
_time_init_ticks(&ticks, 10);
result = _watchdog_create_component(BSP_TIMER_INTERRUPT_VECTOR,
handle_watchdog_expiry);
if (result != MQX_OK) {
printf("\nError creating watchdog component.");
_task_block();
}
n = 100;
while (TRUE) {
result = _watchdog_start_ticks(&ticks);
n = waste_time(n);
_watchdog_stop();
printf("\n %d", n);
}
}
void *thread_func(void *param)
{
unsigned long mask = 1;
if (pthread_setaffinity_np(pthread_self(), sizeof(mask),
&mask) <0) {
perror("pthread_setaffinity_np");
}
printf("result: %f\n", waste_time(2000));
mask = 2;
if (pthread_setaffinity_np(pthread_self(), sizeof(mask),
&mask) <0) {
perror("pthread_setaffinity_np");
}
printf("result: %f\n", waste_time(2000));
}
template<> void TProc3::exec()
{
for(;;) {
PROC3.Off();
ef.wait();
PROC3.On();
waste_time(500);
}
} // TProc3::exec()
int main(int argc, char **argv)
{
unsigned long mask = 1; /* processor 0 */
/* bind process to processor 0 */
if (sched_setaffinity(0, sizeof(mask), &mask) <0) {
perror("sched_setaffinity");
}
/* waste some time so the work is visible with "top" */
printf ("result: %f\n", waste_time (2000));
mask = 2; /* process switches to processor 1 now */
if (sched_setaffinity(0, sizeof(mask), &mask) <0) {
perror("sched_setaffinity");
}
/* waste some more time to see the processor switch */
printf ("result: %f\n", waste_time (2000));
}
child_fn() {
// Child process does some computations and when done, sends a SIGUSR1
int i, j;
printf("Forked new process: ");
printf("pid %d / niceval: %d\n",current->pid, current->stat_prio);
for (;;) {
waste_time(1);
kill(getpid(),SIGABRT);
kill(getpid(),SIGUSR1);
}
}
template<> void TProc2::exec()
{
for(;;) {
PROC2.Off();
sleep(4);
PROC2.On();
ef.signal();
uint8_t request = (OS::get_tick_count() / 1024) % 8;
waste_time(request * 100);
}
} // TProc2::exec()
int main(void)
{
clock_t start;
clock_t spend;
start = clock();
waste_time();
spend = (clock() - start) / CLOCKS_PER_SEC;
printf("Spend %ld seconds.\n", spend);
return 0;
}
int main()
{
int i;
for(i = 0; i < 8; i++) {
set_gpio_pin_direction(i, DIR_IN);
set_pin_function(i, FUNC_GPIO);
}
for(i = 8; i < 16; i++) {
set_gpio_pin_direction(i, DIR_OUT);
set_pin_function(i, FUNC_GPIO);
}
for(i = 16; i < 20; i++) {
set_gpio_pin_direction(i, DIR_IN);
set_pin_function(i, FUNC_GPIO);
}
while(1) {
left_to_right_on_slow(LED_1, LED_7);
left_to_right_off_slow(LED_1, LED_7);
waste_time();
left_to_right_on(LED_1, LED_7);
left_to_right_off(LED_1, LED_7);
waste_time();
left_to_right_single(LED_1, LED_7);
left_to_right_single(LED_1, LED_7);
left_to_right_single(LED_1, LED_7);
}
return 0;
}
void left_to_right_single(unsigned int first, unsigned int last) {
unsigned int i;
unsigned int j;
for(i = first; i <= last; i++) {
for(j = first; j <= last; j++) {
set_gpio_pin_value(j, 0);
}
set_gpio_pin_value(i, 1);
waste_time();
}
}
void *thread_func(void *param)
{
unsigned long mask = 1; /* processor 0 */
unsigned long core;
/* bind process to processor 0 */
if (pthread_setaffinity_np(pthread_self(), sizeof(mask),
&mask) < 0) {
perror("pthread_setaffinity_np");
}
core = pthread_getaffinity_np(pthread_self(), sizeof(mask),&mask);
printf("CPU Core %ld\t" , core);
/* waste some time so the work is visible with "top" */
printf("result: %f\n", waste_time(2000));
mask = 2; /* process switches to processor 1 now */
if (core = pthread_setaffinity_np(pthread_self(), sizeof(mask),
&mask) < 0) {
perror("pthread_setaffinity_np");
}
core = pthread_getaffinity_np(pthread_self(), sizeof(mask),&mask);
printf("CPU Core %ld\t" , core);
/* waste some more time to see the processor switch */
printf("result: %f\n", waste_time(200));
}
int fib (x, depth)
{
int a, b;
waste_time ();
log_transition (&context, depth);
if (x < 2)
return 1;
else
{
a = fib (x-1, depth+1);
log_transition (&context, depth);
b = fib (x-2, depth+1);
log_transition (&context, depth);
return a+b;
}
}
OS_PROCESS void TProc2::exec()
{
for (;;)
{
timer_event.wait();
// increase load, one step at every 5 seconds after start,
// resetting at 8th step.
tick_count_t t = (OS::get_tick_count() % 40000) / 5000;
for (uint32_t i = 0; i < t; i++)
waste_time();
// led "ON" time ~ Proc2 load
red_led::Off();
}
}
OS_PROCESS void TProc0::exec()
{
for(;;)
{
// green led "ON" time = context switch time (~9.6us at 24MHz)
event.wait();
green_led::Off();
// waste some time (imitate payload)
waste_time();
// waste some stack (increasing with time)
tick_count_t t = (OS::get_tick_count() % 40000) / 5000;
waste_stack(t);
}
}
static int
do_work_unit (int who, int n)
{
int i;
static int nchars = 0;
double f = 0.0;
if (quiet)
i = 0;
else {
/*
* get lock on stdout
*/
assert(pthread_mutex_lock (&mutex_stdout) == 0);
/*
* do our job
*/
i = printf ("%c", "0123456789abcdefghijklmnopqrstuvwxyz"[who]);
if (!(++nchars % 50))
printf ("\n");
fflush (stdout);
/*
* release lock on stdout
*/
assert(pthread_mutex_unlock (&mutex_stdout) == 0);
}
n = rand () % 10000; /* ignore incoming 'n' */
f = waste_time (n);
/* This prevents the statement above from being optimised out */
if (f > 0.0)
return(n);
return (n);
}
static int WSS_testport(struct mpxplay_audioout_info_s *aui)
{
unsigned int baseport=aui->card_port;
unsigned int ver1,ver2;
unsigned int i;
//char sout[100];
for(i=0;i<1000;i++){
if(wssinp(WSS_COMMAND_PORT)&0x80){
waste_time(1);
}else{
WSS_writeDSP(baseport,0x0c,0);
//old
//ver1=wssinp(WSS_DATA_PORT)&0xf;
//new
ver1=wssinp(WSS_COMMAND_PORT)&0xf;
//fprintf(stderr,"1. %d. try port:%X ver:%d\n",i,baseport,ver1);
if((ver1>=1)&&(ver1<15))
break;
}
}
if(i==1000)
return 0;
WSS_writeDSP(baseport,0x0c,0);
ver1=wssinp(WSS_DATA_PORT);
wssoutp(WSS_DATA_PORT,0);
ver2=wssinp(WSS_DATA_PORT);
if(ver1!=ver2)
return 0;
if(wssinp(WSS_COMMAND_PORT)&0x80)
return 0;
WSS_writeDSP(baseport,0x49,4);
wssoutp(WSS_COMMAND_PORT, 0x09);
WSS_writeDSP(baseport,0x0c,0);
return 1;
}
template<> void TProc1::exec()
{
const int max_request = 10;
const int increment_period = 1000;
int increment_div = increment_period;
volatile uint8_t dev_null;
uint8_t request = 0;
for(;;) {
PROC1.Off();
Timer3_Ovf.wait();
PROC1.On();
TIMER3_TO_PROC1.Off();
if (request < max_request) {
dev_null = waste_stack(request);
if (--increment_div == 0) {
increment_div = increment_period;
++request;
}
} else {
waste_time(50);
}
}
} // TProc1::exec()
// Simulates a basic epoch processing loop. Since the functions have to be used in a very
// specific way, we try to emulate actual use as much as possible.
//! \todo need to throw in some fail_*.
bool t_epoch_para_worker (yarn_word_t pool_id, void* task) {
(void) pool_id;
(void) task;
for (yarn_word_t i = 0; i < 2000; ++i) {
DBG printf("<%zu> - NEXT - START\n", pool_id);
// Grab the next epoch to execute.
enum yarn_epoch_status old_status;
yarn_word_t epoch;
if(!yarn_epoch_next(&epoch, &old_status)) {
break;
}
// Rollback phase
// Rollback our epoch if necessary.
{
if (old_status == yarn_epoch_rollback) {
DBG printf("<%zu> - NEXT=%zu -> ROLLBACK\n", pool_id, epoch);
waste_time();
yarn_epoch_rollback_done(epoch);
}
else {
DBG printf("<%zu> - NEXT=%zu\n", pool_id, epoch);
}
}
// Execution phase.
// Executes our epoch or randomly trigger rollbacks.
{
waste_time();
if (rand() % 5 == 0) {
DBG printf("<%zu> - ROLLBACK=%zu - START\n", pool_id, epoch+1);
yarn_epoch_do_rollback(epoch+1);
DBG printf("<%zu> - ROLLBACK=%zu - END\n", pool_id, epoch+1);
}
if (i == 1000 + pool_id) {
DBG printf("[%zu] - STOP\n", epoch);
yarn_epoch_stop(epoch);
}
yarn_epoch_set_done(epoch);
}
// Commit phase
// Commit any finished epochs including our own.
{
yarn_word_t to_commit;
void* task;
while(yarn_epoch_get_next_commit(&to_commit, &task)) {
waste_time();
DBG printf("<%zu> - COMMIT=%zu\n", pool_id, to_commit);
yarn_epoch_commit_done(to_commit);
}
}
}
return true;
}
