示例#1
0
/*
 * Main
 */
int main(void) {
	
	init_tlb();
	enable_tlb();
	printf("Hello from Nios II!\n");
	mutex = altera_avalon_mutex_open(MUTEX_0_NAME);	// Initialize the hardware mutex
	mbox = OSSemCreate(0);							// Initialize the message box
	CriticalFunctionPointers* cp = (CriticalFunctionPointers*)SHARED_MEMORY_BASE;

	// Wait for monitor to be done initialization of shared variables before retrieving their values
	while(cp->init_complete == 0);
	init_cpu1_isr();								// Initialize the ISR

	// Set the task(only one in this example)
	int arg_5 = CRITICAL_TASK_PRIORITY;
	OSTaskCreateExt(preemption_task, &arg_5, &critical_task_stk[TASK_STACKSIZE - 1],
					CRITICAL_TASK_PRIORITY, CRITICAL_TASK_PRIORITY,
					critical_task_stk, TASK_STACKSIZE, NULL,0);

	// Signal that the core has finished initializing
	altera_avalon_mutex_lock(mutex, 1);				// Acquire the hardware mutex
	{
		cp->core_ready[1] = 1;
	}
	altera_avalon_mutex_unlock(mutex);				// Memory
	
	// Start OS
	OSStart();
	return 0;
}
示例#2
0
/*
 * This is the wrapper for the task that executes rendundantly on both cores
 * There is one VERY important thing to note. When the critical task begins executing
 * the value of the stack pointer MUST be the same on both cores. This means that
 * the wrapper must have the same number of variables declared within its scope (i.e.
 * onto its stack) before calling the critical task (pt() in this example)
 */
void preemption_task(void* pdata){
	int done = 0;
	int first = 0;
	int t_os;

	CriticalFunctionPointers* cp =
				(CriticalFunctionPointers*) SHARED_MEMORY_BASE;
	pt = cp->task[1];

	while(1){
		// Get initial time, then wait for 2 ticks
		t_os = OSTimeGet();
		OSTimeDly(2 - t_os);

		//This is a crude way of synchronizing the beginning of the task
		//on both cores
		while (done == 0) {
			altera_avalon_mutex_lock(mutex, 1); //Acquire the hardware mutex
			{
				if(first == 0){
					cp->checkout[1] = 1;
					first = 1;
				}
				if( cp->checkout[0] == 1){
					cp->checkout[0] = 0;
					done = 1;
				}

			}
			altera_avalon_mutex_unlock(mutex);
		}

		// Set default block size for fingerprinting
		fprint_set_block_size(cp->blocksize[1]);

		//Context switch is necessary to clear the callee saved registers
		long registers[8];
		context_switch(registers);

		//Set the global pointer in case of compilation issues related
		//to global variables
		set_gp();
		//call the critical task
		pt(cp->args[1]);
		//restore the original global pointer
		restore_gp();
		//Restore the callee saved registers
		context_restore(registers);
		//Get the end time
		alt_u64 t = alt_timestamp();
		//store the end time
		cp->core_time[1] = t;
	}
}
示例#3
0
/*
 * If CPU1 interrupt goes off, we assume that it has been sent
 * by the monitor for now and that a task must be executed.
 * The identity of the task is retrieved from the shared_memory
 * using the CriticalFunctionPointers data structure. The task is then executed
 */
static void handle_cpu1_interrupt(void* context) {
	unsigned short priority;
	altera_avalon_mutex_lock(mutex, 1);
	{

		CriticalFunctionPointers* cp = (CriticalFunctionPointers*)SHARED_MEMORY_BASE;
		priority = cp->priority[1];
		*isr_1_ptr = 0;

	}
	altera_avalon_mutex_unlock(mutex);
	if(priority == CRITICAL_TASK_PRIORITY)
		OSSemPost(mbox);

}
示例#4
0
文件: cpu_3.c 项目: johangas/IL2212
int main()
{
  printf("Hello from cpu_3!\n");
  alt_mutex_dev* mutex = altera_avalon_mutex_open( "/dev/mutex_1" );

  while(TRUE) {
	altera_avalon_mutex_lock( mutex, 1 );
	if (IORD_8DIRECT(FLAG,0) == 1) {
		value=IORD_8DIRECT(VALUE,0);
		printf("Reading from shared memory (safe): %d\n",value);
		IOWR_8DIRECT(VALUE,0,++value);
		IOWR_8DIRECT(FLAG,0,0);
		printf("\tWriting to shared memory (safe): %d\n",value);
	}
	altera_avalon_mutex_unlock( mutex );
	delay(10);
  }

  return 0;
}