Cyclic Executive (ITI8510) - Redigeerimiste ajalugu

Irve – 30. märts 2012, kell 12:21

2012-03-30T12:21:20Z

←Vanem redaktsioon		Redaktsioon: 30. märts 2012, kell 14:21
4. rida:		4. rida:
	Your task is to implement a small cyclic executive, which runs its tasks once in a second, otherwise idling. This will give tasks 3 priorities: normal (once a second), high (interrupts) and low (idling level).		Your task is to implement a small cyclic executive, which runs its tasks once in a second, otherwise idling. This will give tasks 3 priorities: normal (once a second), high (interrupts) and low (idling level).

	The program should handle Ctrl+C interrupt for higher priority tasks. Implementation-wise you should use [http://linux.die.net/man/2/setitimer setitimer()](nice and difficult) or [http://linux.die.net/man/3/alarm alarm()](simple) to deliver a signal every ~~100~~ milliseconds (or 1 second if you are using alarm()) to time the tasks. The SIGALRM should be handled with a handler which sets a global variable (use sig_atomic_t as type).		The program should handle Ctrl+C interrupt for higher priority tasks. Implementation-wise you should use [http://linux.die.net/man/2/setitimer setitimer()](nice and difficult) or [http://linux.die.net/man/3/alarm alarm()](simple) to deliver a signal every 300 milliseconds (or 1 second if you are using alarm()) to time the tasks. The SIGALRM should be handled with a handler which sets a global variable (use sig_atomic_t as type).

	The "Idle" task should do nothing initially except for checking for arrived signal and running the tasks. You may want to add some method for doing low priority tasks, but remember to keep their segments short in order to catch the interrupt flag on time.		The "Idle" task should do nothing initially except for checking for arrived signal and running the tasks. You may want to add some method for doing low priority tasks, but remember to keep their segments short in order to catch the interrupt flag on time.

Irve – 30. märts 2012, kell 12:01

2012-03-30T12:01:45Z

←Vanem redaktsioon		Redaktsioon: 30. märts 2012, kell 14:01
10. rida:		10. rida:
	== The tasks ==		== The tasks ==
	There should be 5 tasks, ''write them as separate functions''.		There should be 5 tasks, ''write them as separate functions''.
	# Get the internal processor tick time with [http://linux.die.net/man/3/clock clock()]		# Get the internal processor tick time with [http://linux.die.net/man/3/clock clock()] (NOTE: clock() function on dijkstra ''is'' weird: don't panic if it does not work as you would imagine; it's not your fault)
	# Get the internal time with [http://linux.die.net/man/2/time time()]		# Get the internal time with [http://linux.die.net/man/2/time time()]
	# check for file "test.txt" in the current directory, if it exists and you can open it, display its content, close it, delete it ( [http://linux.die.net/man/3/unlink unlink()] ).		# check for file "test.txt" in the current directory, if it exists and you can open it, display its content, close it, delete it ( [http://linux.die.net/man/3/unlink unlink()] ).

Irve – 30. märts 2011, kell 18:04

2011-03-30T18:04:59Z

←Vanem redaktsioon		Redaktsioon: 30. märts 2011, kell 20:04
4. rida:		4. rida:
	Your task is to implement a small cyclic executive, which runs its tasks once in a second, otherwise idling. This will give tasks 3 priorities: normal (once a second), high (interrupts) and low (idling level).		Your task is to implement a small cyclic executive, which runs its tasks once in a second, otherwise idling. This will give tasks 3 priorities: normal (once a second), high (interrupts) and low (idling level).

	The program should handle Ctrl+C interrupt for higher priority tasks. Implementation-wise you should use [http://linux.die.net/man/3/alarm alarm()] to deliver a signal every second to time the tasks. The SIGALRM should be handled with a handler which ~~runs the 5 tasks OR~~ sets a global variable (use sig_atomic_t as type).		The program should handle Ctrl+C interrupt for higher priority tasks. Implementation-wise you should use [http://linux.die.net/man/2/setitimer setitimer()](nice and difficult) or [http://linux.die.net/man/3/alarm alarm()](simple) to deliver a signal every 100 milliseconds (or 1 second if you are using alarm()) to time the tasks. The SIGALRM should be handled with a handler which sets a global variable (use sig_atomic_t as type).

	The "Idle" task should do nothing initially except for checking for arrived signal and running the tasks. You may want to add some method for doing low priority tasks, but remember to keep their segments short in order to catch the interrupt flag on time.		The "Idle" task should do nothing initially except for checking for arrived signal and running the tasks. You may want to add some method for doing low priority tasks, but remember to keep their segments short in order to catch the interrupt flag on time.
17. rida:		17. rida:

	* For SIGINT interrupt, write the file "test.txt" with the time stored in task #5. (Note that tasks 1 & 5 only exist to try to keep track of running time)		* For SIGINT interrupt, write the file "test.txt" with the time stored in task #5. (Note that tasks 1 & 5 only exist to try to keep track of running time)
	* (Optional) For idle task, think of something interesting to do which can be interrupted ~~upn~~ SIGALRM arrival.		* (Optional) For idle task, think of something interesting to do which can be interrupted upon SIGALRM arrival.

	'''HINTS'''		'''HINTS'''

Irve – 30. märts 2011, kell 17:59

2011-03-30T17:59:02Z

←Vanem redaktsioon		Redaktsioon: 30. märts 2011, kell 19:59
25. rida:		25. rida:
	== Deadline ==		== Deadline ==

	I'd like the results by ~~March~~, 25. Put the lab into your home directory under "rtos/lab1", name it "cyclic.c". Then send me an e-mail with your student number in it.		I'd like the results by April, 13. Put the lab into your home directory under "rtos/lab1", name it "cyclic.c". Then send me an e-mail with your student number in it.

Irve – 24. märts 2010, kell 14:42

2010-03-24T14:42:24Z

←Vanem redaktsioon		Redaktsioon: 24. märts 2010, kell 16:42
25. rida:		25. rida:
	== Deadline ==		== Deadline ==

	I'd like the results by March, 25. Put the lab into your home directory under "rtos", name it "cyclic.c". Then send me an e-mail with your student number in it.		I'd like the results by March, 25. Put the lab into your home directory under "rtos/lab1", name it "cyclic.c". Then send me an e-mail with your student number in it.

Irve – 24. märts 2010, kell 02:24

2010-03-24T02:24:29Z

Irve – 18. märts 2010, kell 14:17

2010-03-18T14:17:22Z

←Vanem redaktsioon		Redaktsioon: 18. märts 2010, kell 16:17
1. rida:		1. rida:
	{{iti8510}} This lab is part of the end grading. Keep the program in directory "rtos/lab1" and name it cyclic.c for it to be found for checking-script.		{{iti8510}}
			This lab is part of the end grading. Keep the program in directory "rtos/lab1" and name it cyclic.c for it to be found for checking-script.

	Your task is to implement a small cyclic executive, which runs its tasks once in a second, otherwise idling. This will give tasks 3 priorities: normal (once a second), high (interrupts) and low (idling level).		Your task is to implement a small cyclic executive, which runs its tasks once in a second, otherwise idling. This will give tasks 3 priorities: normal (once a second), high (interrupts) and low (idling level).

Irve – 18. märts 2010, kell 13:27

2010-03-18T13:27:28Z

←Vanem redaktsioon		Redaktsioon: 18. märts 2010, kell 15:27
1. rida:		1. rida:
	This lab is part of the end grading. Keep the program in directory "rtos/lab1" and name it cyclic.c for it to be found for checking-script. ~~{{iti8510}}~~		{{iti8510}} This lab is part of the end grading. Keep the program in directory "rtos/lab1" and name it cyclic.c for it to be found for checking-script.

	Your task is to implement a small cyclic executive, which runs its tasks once in a second, otherwise idling. This will give tasks 3 priorities: normal (once a second), high (interrupts) and low (idling level).		Your task is to implement a small cyclic executive, which runs its tasks once in a second, otherwise idling. This will give tasks 3 priorities: normal (once a second), high (interrupts) and low (idling level).

Irve – 18. märts 2010, kell 13:27

2010-03-18T13:27:13Z

←Vanem redaktsioon		Redaktsioon: 18. märts 2010, kell 15:27
1. rida:		1. rida:
	~~{{iti8510}}~~ This lab is part of the end grading. Keep the program in directory "rtos/lab1" and name it cyclic.c for it to be found for checking-script.		This lab is part of the end grading. Keep the program in directory "rtos/lab1" and name it cyclic.c for it to be found for checking-script. {{iti8510}}

	Your task is to implement a small cyclic executive, which runs its tasks once in a second, otherwise idling. This will give tasks 3 priorities: normal (once a second), high (interrupts) and low (idling level).		Your task is to implement a small cyclic executive, which runs its tasks once in a second, otherwise idling. This will give tasks 3 priorities: normal (once a second), high (interrupts) and low (idling level).

Irve – 18. märts 2010, kell 13:26

2010-03-18T13:26:54Z

←Vanem redaktsioon		Redaktsioon: 18. märts 2010, kell 15:26
1. rida:		1. rida:
	{{~~itv8510~~}}This lab is part of the end grading. Keep the program in directory "rtos/lab1" and name it cyclic.c for it to be found for checking-script.		{{iti8510}} This lab is part of the end grading. Keep the program in directory "rtos/lab1" and name it cyclic.c for it to be found for checking-script.

	Your task is to implement a small cyclic executive, which runs its tasks once in a second, otherwise idling. This will give tasks 3 priorities: normal (once a second), high (interrupts) and low (idling level).		Your task is to implement a small cyclic executive, which runs its tasks once in a second, otherwise idling. This will give tasks 3 priorities: normal (once a second), high (interrupts) and low (idling level).

←Vanem redaktsioon		Redaktsioon: 24. märts 2010, kell 04:24
4. rida:		4. rida:
	Your task is to implement a small cyclic executive, which runs its tasks once in a second, otherwise idling. This will give tasks 3 priorities: normal (once a second), high (interrupts) and low (idling level).		Your task is to implement a small cyclic executive, which runs its tasks once in a second, otherwise idling. This will give tasks 3 priorities: normal (once a second), high (interrupts) and low (idling level).

	The program should handle Ctrl+C interrupt for higher priority tasks. Implementation-wise you should use [http://linux.die.net/man/3/alarm alarm()] to deliver a signal every second to time the tasks. The SIGALRM should be handled with a handler which runs the 3 tasks OR sets a global variable (use sig_atomic_t as type).		The program should handle Ctrl+C interrupt for higher priority tasks. Implementation-wise you should use [http://linux.die.net/man/3/alarm alarm()] to deliver a signal every second to time the tasks. The SIGALRM should be handled with a handler which runs the 5 tasks OR sets a global variable (use sig_atomic_t as type).

	The "Idle" task should do nothing initially except for checking for arrived signal and running the tasks. You may want to add some method for doing low priority tasks, but remember to keep their segments short in order to catch the interrupt flag on time.		The "Idle" task should do nothing initially except for checking for arrived signal and running the tasks. You may want to add some method for doing low priority tasks, but remember to keep their segments short in order to catch the interrupt flag on time.
14. rida:		14. rida:
	# check for file "test.txt" in the current directory, if it exists and you can open it, display its content, close it, delete it ( [http://linux.die.net/man/3/unlink unlink()] ).		# check for file "test.txt" in the current directory, if it exists and you can open it, display its content, close it, delete it ( [http://linux.die.net/man/3/unlink unlink()] ).
	# Display the time() value on screen (that you got in task #2)		# Display the time() value on screen (that you got in task #2)
	# Get the processor tick time with clock() function and store the amount of time since task 1 to a variable ~~for SIGINT~~.		# Get the processor tick time with clock() function and store the amount of time since task 1 to a global variable.

	* For SIGINT interrupt, write the file "test.txt" with the time stored in task #5 .		* For SIGINT interrupt, write the file "test.txt" with the time stored in task #5. (Note that tasks 1 & 5 only exist to try to keep track of running time)
	* (Optional) For idle task, think of something interesting to do which can be ~~easily~~ interrupted ~~if sigalrm arrives~~.		* (Optional) For idle task, think of something interesting to do which can be interrupted upn SIGALRM arrival.

	'''HINTS'''		'''HINTS'''
	* For printing the clock() value, you can cast it to some type that you can show (for printf("%d\n", (int)clockvalue might work).		* For printing the clock() value, you can cast it to some type that you can show (for printf("%d\n", (int)clockvalue might work).
	* You can probably adapt some of the code from the ~~intterrupt~~ practice assignment.		* You can probably adapt some of the code from the interrupt practice assignment.

	== Deadline ==		== Deadline ==

	I'd like the results by March, 25. Put the lab into your home directory under "rtos", name it "cyclic.c". Then send me an e-mail with your student number in it.		I'd like the results by March, 25. Put the lab into your home directory under "rtos", name it "cyclic.c". Then send me an e-mail with your student number in it.