Threads (ITI8510) - Redigeerimiste ajalugu

Irve – 8. oktoober 2014, kell 21:07

2014-10-08T21:07:43Z

←Vanem redaktsioon		Redaktsioon: 8. oktoober 2014, kell 23:07
11. rida:		11. rida:
	all: threaded_hello		all: threaded_hello

	threaded_hello: ~~threaded.hello~~.c		threaded_hello: threaded_hello.c
	gcc -pthread threaded_hello.c -o threaded_hello.o		gcc -pthread threaded_hello.c -o threaded_hello.o

Irve: /* Task */

2013-10-09T17:35:53Z

Task

←Vanem redaktsioon		Redaktsioon: 9. oktoober 2013, kell 19:35
28. rida:		28. rida:
	4. We need to protect the shared variable using a mutex. Use [http://sourceware.org/pthreads-win32/manual/pthread_mutex_init.html pthread_mutex_*] functions. The logic to mutex is that you have to acquire mutex before doing work with shared data and have to release it after finishing with it. While the mutex is in the hands of a thread, the other threads who want to lock it block (wait) until the lock is released. ''Show it''		4. We need to protect the shared variable using a mutex. Use [http://sourceware.org/pthreads-win32/manual/pthread_mutex_init.html pthread_mutex_*] functions. The logic to mutex is that you have to acquire mutex before doing work with shared data and have to release it after finishing with it. While the mutex is in the hands of a thread, the other threads who want to lock it block (wait) until the lock is released. ''Show it''

	5. Improve your program by adding two arguments a thread that will run: the arguments should be the arguments to the program (to main()). Running your program as follows:		5. For the last task, we explore how you could pass several arguments to a thread. Improve your program by adding two arguments for a thread that will run: the arguments should be the arguments to the program (to main()); pass them to the thread using an argument to the pthread_create() function. Running your program as follows:
	threadexperiment test1 test2		threadexperiment test1 test2
	The output should be as follows:		The output should be as follows:
	Hello, test1 test2		Hello, test1 test2
	If there are less than 2 arguments, exit. ''Show it''		If there are less than 2 arguments, exit. ''Show it''

Irve: /* Task */

2013-10-09T17:10:54Z

Task

←Vanem redaktsioon		Redaktsioon: 9. oktoober 2013, kell 19:10
27. rida:		27. rida:

	4. We need to protect the shared variable using a mutex. Use [http://sourceware.org/pthreads-win32/manual/pthread_mutex_init.html pthread_mutex_*] functions. The logic to mutex is that you have to acquire mutex before doing work with shared data and have to release it after finishing with it. While the mutex is in the hands of a thread, the other threads who want to lock it block (wait) until the lock is released. ''Show it''		4. We need to protect the shared variable using a mutex. Use [http://sourceware.org/pthreads-win32/manual/pthread_mutex_init.html pthread_mutex_*] functions. The logic to mutex is that you have to acquire mutex before doing work with shared data and have to release it after finishing with it. While the mutex is in the hands of a thread, the other threads who want to lock it block (wait) until the lock is released. ''Show it''


	5. Improve your program by adding two arguments a thread that will run: the arguments should be the arguments to the program (to main()). Running your program as follows:		5. Improve your program by adding two arguments a thread that will run: the arguments should be the arguments to the program (to main()). Running your program as follows:

Irve: /* Task */

2013-10-09T17:10:45Z

Task

←Vanem redaktsioon		Redaktsioon: 9. oktoober 2013, kell 19:10
24. rida:		24. rida:
	2. Write a program which uses two threads which both run 100000 times while adding 1 to a single shared variable (global variable). It will (hopefully) not count correctly due to race conditions.		2. Write a program which uses two threads which both run 100000 times while adding 1 to a single shared variable (global variable). It will (hopefully) not count correctly due to race conditions.

	3. We need to protect the shared variable using a mutex. Use [http://sourceware.org/pthreads-win32/manual/pthread_mutex_init.html pthread_mutex_*] functions. The logic to mutex is that you have to acquire mutex before doing work with shared data and have to release it after finishing with it. While the mutex is in the hands of a thread, the other threads who want to lock it block (wait) until the lock is released. ''Show it''		3. Modity the program to use ''detached'' threads. Note that you might want to call pthread_exit() from the main function to let the threads finish.

			4. We need to protect the shared variable using a mutex. Use [http://sourceware.org/pthreads-win32/manual/pthread_mutex_init.html pthread_mutex_*] functions. The logic to mutex is that you have to acquire mutex before doing work with shared data and have to release it after finishing with it. While the mutex is in the hands of a thread, the other threads who want to lock it block (wait) until the lock is released. ''Show it''

	~~4. Modity the program to use ''detached'' threads. Note that you might want to call pthread_exit() from the main function to let the threads finish.~~

	5. Improve your program by adding two arguments a thread that will run: the arguments should be the arguments to the program (to main()). Running your program as follows:		5. Improve your program by adding two arguments a thread that will run: the arguments should be the arguments to the program (to main()). Running your program as follows:

Irve: /* Task */

2013-10-09T17:08:54Z

Task

←Vanem redaktsioon		Redaktsioon: 9. oktoober 2013, kell 19:08
24. rida:		24. rida:
	2. Write a program which uses two threads which both run 100000 times while adding 1 to a single shared variable (global variable). It will (hopefully) not count correctly due to race conditions.		2. Write a program which uses two threads which both run 100000 times while adding 1 to a single shared variable (global variable). It will (hopefully) not count correctly due to race conditions.

	3. ~~Modity~~ the ~~program~~ to ~~use ''detached'' threads. Note~~ that you ~~might~~ want to ~~call pthread_exit~~() ~~from the main function to let~~ the ~~threads finish~~.		3. We need to protect the shared variable using a mutex. Use [http://sourceware.org/pthreads-win32/manual/pthread_mutex_init.html pthread_mutex_*] functions. The logic to mutex is that you have to acquire mutex before doing work with shared data and have to release it after finishing with it. While the mutex is in the hands of a thread, the other threads who want to lock it block (wait) until the lock is released. ''Show it''

	4. ~~We need~~ to ~~protect the shared variable using a mutex~~. ~~Use [http://sourceware.org/pthreads-win32/manual/pthread_mutex_init.html pthread_mutex_*] functions. The logic to mutex is~~ that you ~~have to acquire mutex before doing work with shared data and have to release it after finishing with it. While the mutex is in the hands of a thread, the other threads who~~ want to ~~lock it block~~ (~~wait~~) ~~until~~ the ~~lock is released~~. ~~''Show it''~~		4. Modity the program to use ''detached'' threads. Note that you might want to call pthread_exit() from the main function to let the threads finish.

	5. Improve your program by adding two arguments a thread that will run: the arguments should be the arguments to the program (to main()). Running your program as follows:		5. Improve your program by adding two arguments a thread that will run: the arguments should be the arguments to the program (to main()). Running your program as follows:

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

2011-03-30T18:09:59Z

←Vanem redaktsioon		Redaktsioon: 30. märts 2011, kell 20:09
22. rida:		22. rida:
	1. Write and run a threaded "Hello, World" program. You need thread creation pthread_create() and pthread_join() commands.		1. Write and run a threaded "Hello, World" program. You need thread creation pthread_create() and pthread_join() commands.

	2. Improve your program by adding two arguments ~~to the~~ thread that will run: the arguments should be the arguments to the program. Running your program as follows:		2. Write a program which uses two threads which both run 100000 times while adding 1 to a single shared variable (global variable). It will (hopefully) not count correctly due to race conditions.

			3. Modity the program to use ''detached'' threads. Note that you might want to call pthread_exit() from the main function to let the threads finish.

			4. We need to protect the shared variable using a mutex. Use [http://sourceware.org/pthreads-win32/manual/pthread_mutex_init.html pthread_mutex_*] functions. The logic to mutex is that you have to acquire mutex before doing work with shared data and have to release it after finishing with it. While the mutex is in the hands of a thread, the other threads who want to lock it block (wait) until the lock is released. ''Show it''

			5. Improve your program by adding two arguments a thread that will run: the arguments should be the arguments to the program (to main()). Running your program as follows:
	threadexperiment test1 test2		threadexperiment test1 test2
	The output should be as follows:		The output should be as follows:
	Hello, test1 test2		Hello, test1 test2
	If there are less than 2 arguments, exit. ''Show it''		If there are less than 2 arguments, exit. ''Show it''

	~~3. Write a program which uses two threads which both run 100000 times while adding 1 to a single shared variable (global variable). It should not count correctly due to race conditions.~~

	~~4. Modity the program to use ''detached'' threads. Note that you might want to call pthread_exit() from the main function to let the threads finish.~~

	5. We need to protect the shared variable using a mutex. Use [http://sourceware.org/pthreads-win32/manual/pthread_mutex_init.html pthread_mutex_*] functions. The logic to mutex is that you have to acquire mutex before doing work with shared data and have to release it after finishing with it. While the mutex is in the hands of a thread, the other threads who want to lock it block (wait) until the lock is released. ''Show it''

Irve – 23. märts 2011, kell 19:40

2011-03-23T19:40:32Z

←Vanem redaktsioon		Redaktsioon: 23. märts 2011, kell 21:40
6. rida:		6. rida:
	You will note that using		You will note that using
	#include <pthread.h>		#include <pthread.h>
	in your program is not enough. It will still not compile. This is due to the fact that gcc needs additional library information and should be executed with -~~lpthread~~ option.		in your program is not enough. It will still not compile. This is due to the fact that gcc needs additional library information and should be executed with -pthread option.

	It would be helpful to use a makefile for further compilation. Create a file named Makefile in the directory of the program with contents similar to following (assuming that you named your program "threaded_hello.c"):		It would be helpful to use a makefile for further compilation. Create a file named Makefile in the directory of the program with contents similar to following (assuming that you named your program "threaded_hello.c"):

Irve: /* Compilation */

2011-03-23T19:22:43Z

Compilation

←Vanem redaktsioon		Redaktsioon: 23. märts 2011, kell 21:22
6. rida:		6. rida:
	You will note that using		You will note that using
	#include <pthread.h>		#include <pthread.h>
	in your program is not enough. It will still not compile. This is due to the fact that gcc needs additional library information and should be executed with -~~pthread~~ option.		in your program is not enough. It will still not compile. This is due to the fact that gcc needs additional library information and should be executed with -lpthread option.

	It would be helpful to use a makefile for further compilation. Create a file named Makefile in the directory of the program with contents similar to following (assuming that you named your program "threaded_hello.c"):		It would be helpful to use a makefile for further compilation. Create a file named Makefile in the directory of the program with contents similar to following (assuming that you named your program "threaded_hello.c"):

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

2010-03-18T14:17:13Z

←Vanem redaktsioon		Redaktsioon: 18. märts 2010, kell 16:17
1. rida:		1. rida:
	{{Iti8510}}This lab will deal with threads, their creation and common data protection. For (more than thorough) explanation on threads, you can read [https://computing.llnl.gov/tutorials/pthreads/ POSIX Threads Programming]. Threads and mutexes can be used for experimenting with concurrency with sharing of the memory space: something which could happen while programming a chip.		{{Iti8510}}
			This lab will deal with threads, their creation and common data protection. For (more than thorough) explanation on threads, you can read [https://computing.llnl.gov/tutorials/pthreads/ POSIX Threads Programming]. Threads and mutexes can be used for experimenting with concurrency with sharing of the memory space: something which could happen while programming a chip.

	== Compilation ==		== Compilation ==

Irve – 4. märts 2010, kell 15:20

2010-03-04T15:20:02Z

←Vanem redaktsioon		Redaktsioon: 4. märts 2010, kell 17:20
7. rida:		7. rida:
	in your program is not enough. It will still not compile. This is due to the fact that gcc needs additional library information and should be executed with -pthread option.		in your program is not enough. It will still not compile. This is due to the fact that gcc needs additional library information and should be executed with -pthread option.

	It would be helpful to use a makefile for further compilation. Create a file named Makefile in the directory of the program with contents similar to following (assuming that you ~~use~~ "threaded_hello.c" ~~as base program~~:		It would be helpful to use a makefile for further compilation. Create a file named Makefile in the directory of the program with contents similar to following (assuming that you named your program "threaded_hello.c"):
	all: threaded_hello		all: threaded_hello