void timer_intr(void)
{
timer_systime_counter.low++;
if(timer_systime_counter.low >= TIMER_SYSTIME_LOW_RESO) {
timer_systime_counter.high++;
timer_systime_counter.low = 0;
}
pic_eoi(PIC_IRQ_TIMER); /* notify "Reception completion" to PIC */
/*
{
static char i=0;
int pos;
char s[4];
byte2hex(i,s);
i++;
pos = console_getpos();
console_locatepos(77,0);
console_puts(s);
console_putpos(pos);
}
*/
alarm_check();
task_tick();
task_dispatch();
return;
}
PUBLIC s32 os_sleep(u32 ms)
{
u32 ticks = (ms * OS_HZ) / 1000;
current_task->sleep_ticks = ticks;
current_task->state = TASK_SLEEP;
task_dispatch();
return 0;
}
PRIVATE void os_clock_irq_hook(struct cpu_context *ctx)
{
struct __os_task__ *best_task;
os_tick ++ ;
os_sleep_expire();
best_task = get_best_task();
if (best_task == NULL) {
kassert(current_task == &tcb[IDLE_TASK_ID]);
} else if (best_task->prio <= current_task->prio) {
current_task->state = TASK_READY;
task_dispatch();
}
}
int main(void){
init_devices();
//
// start at least one task here
//
set_task(7); //task7 runs
set_task(6); //task6 runs
// main loop
while(1){
if (tick_flag){
tick_flag = 0;
task_dispatch(); // well....
}
}
return 0;
}
bool MTFloatRun(Node * node)
{
std::vector<sub_op_task> task_list;
for(int i=0;i<cpu_info->GetCPUNumber()*2;i++)
{
sub_op_task task;
task.exec_func=std::bind(&DemoOps::FloatAider,this,std::placeholders::_1,
std::placeholders::_2,std::placeholders::_3);
task.seq=i;
task.data=(void *)((unsigned long)i);
task_list.push_back(task);
}
task_dispatch(task_list,-1);
wait_done();
return true;
}
bool Run(Node * node)
{
const Tensor * input_tensor=node->GetInputTensor(0);
Tensor * output_tensor=node->GetOutputTensor(0);
const TShape& shape=input_tensor->GetShape();
const std::vector<int> dims=shape.GetDim();
int batch_number=dims[0];
int channel_num=dims[1];
int channel_size=dims[2]*dims[3];
Tensor * gamma_tensor=node->GetInputTensor(1);
Tensor * beta_tensor=node->GetInputTensor(2);
Tensor * mean_tensor=node->GetInputTensor(3);
Tensor * var_tensor=node->GetInputTensor(4);
float * gamma=(float *)get_tensor_mem(gamma_tensor);
float * beta=(float *)get_tensor_mem(beta_tensor);
float * mean=(float *)get_tensor_mem(mean_tensor);
float * var=(float *)get_tensor_mem(var_tensor);
const float * input=(const float *)get_tensor_mem(input_tensor);
float * output=(float *)get_tensor_mem(output_tensor);
int cpu_number=cpu_info->GetCPUNumber();
for(int i=0;i<batch_number;i++)
{
if(cpu_number==1)
{
bn_scale_relu_neon(input,gamma,beta,mean,var,channel_num,channel_size,output);
input+=channel_size*channel_num;
output+=channel_size*channel_num;
}
else
{
std::vector<sub_op_task> task_list;
std::vector<BNParam> param_list;
auto f=std::bind(&FusedOps::Aider,this,std::placeholders::_1,
std::placeholders::_2,std::placeholders::_3);
int step=(channel_num+(cpu_number-1))/cpu_number;
if(channel_num-(cpu_number-1)*step<=0)
step=channel_num/cpu_number;
task_list.resize(cpu_number);
param_list.resize(cpu_number);
for(int i=0;i<cpu_number;i++)
{
BNParam * param=¶m_list[i];
sub_op_task * task=&task_list[i];
task->exec_func=f;
task->seq=i;
task->data=param;
param->input=input;
param->gamma=gamma;
param->beta=beta;
param->mean=mean;
param->var=var;
param->channel_num=step;
param->channel_size=channel_size;
param->output=output;
input+=channel_size*step;
output+=channel_size*step;
gamma+=step;
beta+=step;
mean+=step;
var+=step;
}
param_list[cpu_number-1].channel_num=channel_num-(cpu_number-1)*step;
task_dispatch(task_list,-1);
wait_done();
}
/*
the c code of assembly code
for(int c=0;c<channel_num;c++)
{
float s_mean=mean[c];
float s_var=var[c];
float s_gamma=gamma[c];
float s_beta=beta[c];
for(int l=0;l<channel_size;l++)
{
float data=input[l];
data=data*s_var+s_mean;
data=data*s_gamma+s_beta;
if(data<0.0)
data=0;
output[l]=data;
}
input+=channel_size;
output+=channel_size;
}
*/
}
return true;
}