MESSAGE
| DATE | 2015-03-26 |
| FROM | Ruben Safir
|
| SUBJECT | Subject: [LIU Comp Sci] Cpt 4 HW from pr 13-18
|
From owner-learn-outgoing-at-mrbrklyn.com Thu Mar 26 00:10:47 2015
Return-Path:
X-Original-To: archive-at-mrbrklyn.com
Delivered-To: archive-at-mrbrklyn.com
Received: by mrbrklyn.com (Postfix)
id 6EFCD16133E; Thu, 26 Mar 2015 00:10:47 -0400 (EDT)
Delivered-To: learn-outgoing-at-mrbrklyn.com
Received: by mrbrklyn.com (Postfix, from userid 28)
id 56F4B161342; Thu, 26 Mar 2015 00:10:47 -0400 (EDT)
Delivered-To: learn-at-nylxs.com
Received: from mailbackend.panix.com (mailbackend.panix.com [166.84.1.89])
by mrbrklyn.com (Postfix) with ESMTP id 9574716133E
for ; Thu, 26 Mar 2015 00:10:23 -0400 (EDT)
Received: from [10.0.0.19] (unknown [96.57.23.82])
by mailbackend.panix.com (Postfix) with ESMTPSA id 75F9412593;
Thu, 26 Mar 2015 00:10:22 -0400 (EDT)
Message-ID: <551386AE.4000704-at-panix.com>
Date: Thu, 26 Mar 2015 00:10:22 -0400
From: Ruben Safir
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:31.0) Gecko/20100101 Thunderbird/31.3.0
MIME-Version: 1.0
To: mohammed Ghriga , 643-at-ghriga.com
Subject: [LIU Comp Sci] Cpt 4 HW from pr 13-18
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Sender: owner-learn-at-mrbrklyn.com
Precedence: bulk
Reply-To: learn-at-mrbrklyn.com
After this is programming and I need to set up for them. It will likely
be finished tomorrow
and be catching up to chapter 5 and the Unix command line stuff that I
can't wait to do :).
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4.13
Determine if the following problems exhibit task or data parallelism:
• The multithreaded statistical program described in Exercise 4.21
Task, at least as i would right it
• The multithreaded Sudoku validator described in Project 1 in this
chapter.
Data, sort of. Each of the long lines are different data for the
same task and the boxes might be different taks, also multiuple times
over different data.
• The multithreaded sorting program described in Project 2 in this
chapter
Data
• The multithreaded web server described in Section 4.1
Task
4.14
A system with two dual-core processors has four processors available
for scheduling. A CPU-intensive application is running on this system.
All input is performed at program start-up, when a single file must
be opened. Similarly, all output is performed just before the program
terminates, when the program results must be written to a single
file. Between startup and termination, the program is entirely CPU -
bound. Your task is to improve the performance of this application
by multithreading it. The application runs on a system that uses the
one-to-one threading model (each user thread maps to a kernel thread).
• How many threads will you create to perform the input and output?
Explain.
One - it is a single input and it needs to wait for the interupt and DMA.
There is not much you can do to speed it up. Assuming it is large enough,
just suck it in. It says that all input must be done at start up. I would
add, however, that the devil is in the details here. If it makes more sense
to open a file and do continous or random reads, the it should be threaded,
depending on what is happenins with the data.
• How many threads will you create for the CPU-intensive portion of
the application? Explain.
4 threads, using OPM probably. You can do more incase of error blocks
or other synchonys blocks, but one thread per CPU will maximix NUMA
and bus contention.
4.15 Consider the following code segment:
pid t pid;
a.
b.
pid = fork();
if (pid == 0) { /* child process */
fork();
thread create( . . .);
}
fork();
How many unique processes are created?
4
How many unique threads are created?
2
4.16
As described in Section 4.7.2, Linux does not distinguish between
processes and threads. Instead, Linux treats both in the same way,
allowing a task to be more akin to a process or a thread depending on the
set of flags passed to the clone() system call. However, other operating
systems, such as Windows, treat processes and threads differently.
Typically, such systems use a notation in which the data structure for
a process contains pointers to the separate threads belonging to the
process. Contrast these two approaches for modeling processes and
threads within the kernel.
Yes - the Windows method SUCKS and is difficult to write on the OS
level and debug on the user level. Don't use MS products.
4.17 The program shown in Figure 4.16 uses the Pthreads API. What would
be the output from the program at LINE C and LINE P?
5 from the child and 0 from the parent...
#include
#include
#include
int value = 0;
void *runner(void *param); /* the thread */
int main(int argc, char *argv[])
{
pid t pid;
pthread t tid;
pthread attr t attr;
pid = fork();
if (pid == 0) { /* child process */
pthread attr init(&attr);
pthread create(&tid,&attr,runner,NULL);
pthread join(tid,NULL);
printf("CHILD: value = %d",value); /* LINE C */
}
else if (pid > 0) { /* parent process */
wait(NULL);
printf("PARENT: value = %d",value); /* LINE P */
}
}
void *runner(void *param) {
value = 5;
pthread exit(0);
}
4.18 Consider a multicore system and a multithreaded program written
using the many-to-many threading model. Let the number of user-level
threads in the program be greater than the number of processing cores
in the system. Discuss the performance implications of the following
scenarios.
A) The number of kernel threads allocated to the program is less than
the number of processing cores.
user threads that need kernel resources will be blocked and qued as
necessary
B) The number of kernel threads allocated to the program is equal to
the number of processing cores.
That should allow for one thread per kernel thread and max out utilization
C) The number of kernel threads allocated to the program is greater
than the number of processing cores but less than the number of
user-level threads.
Kernel threads are expensive and should be reduced by the OS instead of
wasting resources
although there is a significant cost to starting threads.
|
|
