Soma-notes - User contributions [en]

Talk:COMP 3000 Essay 2 2010 Question 8

2010-12-01T16:22:57Z

Tmalone: /* Other Information */

Group Members

Trevor Bonesaw Malone - tmalone@connect.carleton.ca //FIRST POST!

Qi Zhang - qzhang13@connect.carleton.ca

Gregory Bint - gbint@connect.carleton.ca

Gautam Akiwate - gakiwate@connect.carleton.ca

Corey Ling - cling@connect.carleton.ca

Sarah Liske

==Relevant Sources==
*NEWSOME,J.,AND SONG,D.Dynamic Taint Analysis for Automatic Detection, Analysis, and Signature Generation of Exploits on Commodity Software. [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.2141&rep=rep1&type=pdf Dynamic Taint Analysis for Automatic Detection]
Seems to be THE Dynamic Taint Analysis Paper.Talks about implementation on TaintCheck. Could be also useful for critique section -[Gautam]

== Work Plan ==

As Trevor intimated, we should have clear division of work going forward. This is sort of the break down as I see it. Please edit as you think of new ideas!

* Background Concepts
** Information Flow Theory. (Implicit and Explicit Flows.) --Done[--[[User:Gautam|Gautam]] 03:54, 28 November 2010 (UTC)]
** What is dynamic taint analysis --Done[--[[User:Gautam|Gautam]] 05:07, 28 November 2010 (UTC)]
** What is the difference between dynamic and static analysis - it's there, who added it?
* Research Problem
** How do we build a DTA engine for a phone? - done, but by who?
** Why do we want to? (information misuse) - done, but by who?
* Contribution
** How did they implement their DTA engine (Done: --[[User:Cling|Cling]] 04:50, 26 November 2010 (UTC))
** What did they find about information misuse (Done: --[[User:Cling|Cling]] 04:50, 26 November 2010 (UTC))
** Compared to the existing taint tracking approaches. [[User:Zhangqi|Zhangqi]] 07:11, 27 November 2010 (UTC) (Added something. Still looking for other examples,in progress)
** (What else should be in the contributions? Anything need fleshing out?) (Working on that now :) sliske
* Critique
**Added two paragraphs at the end of the present critique. Please incorporate it into your content as you deem fit.--[[User:Gautam|Gautam]] 09:07, 30 November 2010 (UTC)
**^ done. fleshed out critique, and added a bit about how taintdroid doesn't track implicit flow. Also reworded (the entire essay) for clarity where necessary/checked spelling. It would be a good idea for everyone to read it over once for spelling/clarity before thursday, just in case something doesn't make sense - sliske
* References
** The article has 61 references! We can probably use some of them
**whee! reading papers and sticking in information as need be. Also working out how to cite properly, as there are two citations used currently sliske

List of information we need to find external sources for:
* History of taint analysis
* History of privacy research relating to smart phones

== Work In Progress ==

Log what you are working on *right now* so that other people don't try to do the same thing. Make sure to clear your name from here when you are done.

* Gregory Bint: Research Problem
** Need to find some history on smart phone security research for the second part.

* Gautam Akiwate: Background Concepts
** Any resources on Dynamic taint Analysis would be appreciated!

* Corey Ling: Contributions (Qi Zhang)

* Trevor Malone: Critique

* Sarah Liske: References and Questions, Clarity/Spelling.

== Some Notes from the Video ==

Tracking of privacy sensitive data through Dynamic Taint Analysis (aka. Taint Tracking). The trick is to mark private data as it sourced, and then follow those marks until (unless) they leave the phone.

Android phones run Java apps, which are compiled into DEX, and then run on top of the Dalvik VM. It is this VM that we modify so that we can support the storage and tracking of taint tags.

Taint sources
* low -bandwidth sensors
** Location
** Accelerometer
* High-bandwidth sensors
** Mic
** Camera
* Information DB
** Address book
** SMS storage
* Device ID
** IMEI
** IMSI (don't actually track this one because of false positives)
** ICC_ID
** Phone Number

Taint sink (where marked data can leave the phone)
* Network Taint Sink

Taint propagation
* ???

Taint tags are stored in memory interleaved with the variables they are tracking

Some standard Data Flow technique is used to propagate these tags, especially as one variable that is marked may be assigned to another, so now that variable needs to be tracked as well.

Tracks explicit flows of data, not implicit
To fully capture implicit flows, you need to do static analysis, which is hard with closed-source apps, and cannot be done real-time

Implicit flows are not tracked
* Implicit flows can involve "taint-scope", tracking based on conditionals in code

=== Performance ===

The goal is to create a real time tracking system, so the TaintDroid's performance impact is of some importance

14% CPU overhead
4.4% memory overhead

Macro benchmarks (to get a feel for what the phone's usability is like with TD running)
* App load: 3% (2ms)

=== Findings ===

20 out of 30 tested applications share data in a way that is not expected.

67 of 105 flagged pieces of data leaving the device had no obviously legitimate purpose (verified by the authors).

Many apps sent location data and other unique identifiers to advertising servers.

Most apps do not mention anything to the user.

=== Limitations ===

Tracks only explicit data flows.

An application *could* launder the tags off of the data, if they really wanted to hide this sort of thing from TaintDroid.

There are methods that could be used to protect against this, but they go against the goal of a light-weight, real-time tracking system. TD is not necessarily about catching truly malicious programs, but rather just those that leak information.

Why do apps take this information?
* Lazy; in the demo video, the wallpaper app seems to use the IMEI just as a ready made unique ID
* Overzealous; the developer might thing they *need* the data for something, but actually
* Ads; advertises do seem a little presumptuous in their data collection
* Spying; bosses or spouses
* Malicious;

=== QA Period ===

Q: how do we prevent a malicious app from removing a taint attribute on a file

A: TD operates a too low a level for this to be a problem; TD assumes that the native code is trusted

Q: It seems like you had a lot of false positives

A: The point of this tool was to identify privacy sensitive information as having left the phone, not whether or not a privacy violation has taken place.

Q: Now that TD is released; couldn't malicious apps use some of the methods described in the paper to get around it?

A: Well, yes, but it is not just about maliciousness, it could just laziness or over-zealous ad stuff.

==Other Information==

Hey guys, thought I would just post a generalized paragraph about our essay.

In today’s society, Smartphones are the new big thing. To me that’s what makes this paper so interesting. This paper focuses on private information in android phones and the misuse of this information. The misuse of information includes the SIM card, the ID of the device, or the phone number. TaintDroid is used on smart phones with an efficient taint tracking and analysis system. It has the ability to track sensitive data from multiple sources and examines the misuse of such data. In their study, out of 80 popular third-party applications, TaintDroid monitored that 68 applications had potential misuse of user’s private data. This tool is great for knowing with applications are safe and which are not, so your private data can remained private.

Also, we should really think of splitting up the work in some way. If some people have specific sections they would like to do lets figure that out now so we can divide the workload and get it done over the next couple of days. I don't personally care what part I'm going to have to do, so lets get this going. Any other information people wanna post feel free the more the better, even if we don't end up using it.

[[user:Tmalone|Trevor Malone]]

Hey guys! Anything else we need to get done? Let me know and I can help in anyway possible.

[[user:Tmalone|Trevor Malone]]

COMP 3000 Essay 2 2010 Question 8

2010-11-29T18:12:28Z

Tmalone: /* Critique */

=Paper=

<big><big>TaintDroid: An Information-Flow Tracking System for Realtime Privacy Monitoring on Smartphones</big></big>

Authors:
* William Enck, ''The Pennsylvania State University''
* Peter Gilbert, ''Duke University''
* Byung-Gon Chun, ''Intel Labs''
* Landon P. Cox, ''Duke University''
* Jaeyeon Jung, ''Intel Labs''
* Patrick McDaniel, ''The Pennsylvania State University''
* Anmol N. Sheth, ''Intel Labs''

Official Website: http://www.appanalysis.org/

Direct Link to Paper: http://appanalysis.org/tdroid10.pdf

Video demonstration of TaintDroid in action: http://www.youtube.com/watch?v=qnLujX1Dw4Y

=Background Concepts=
As a brief glance through the paper might suggest the paper has much to do with "Information Flow Tracking" and "Dynamic Taint Analysis".It is evident that to follow these ideas in this paper the ideas which form the basis of this theory have to be understood. All in all, the following two concepts can be said to be central to understanding this paper. 
*Information Flow
*Taint Analysis
'''<big>Information Flow</big>''' 
Information flow as the name suggests is essentially transfer of information. This transfer of information can be between two processes or withing a given process from let's say a variable x to a variable y. Information Flow Theory tries to quantify this '''flow''' of information into a mathematical model. 
In a security model the Information Flow can be categorized into: 
'''Explicit Flow''' 
Explicit Flow is when information subject to 'security classifications' is transfered to a variable(or process) which is not subject to the same or higher level of 'security' causing a security breach. To put simply explicit flow is when 'secure' information is transferred so that it is publicly observable. 
A Pseudo Code Example: 
<code>PRIVATE VAR <big>secure</big> 
PUBLIC VAR <big>notsecure 
notsecure=secure</big> </code>
In the information in 'secure' which is PRIVATE is transferred to 'notsecure' which is PUBLIC which is an 'Information Leak'.
 
'''Implicit Flow''' 
Implicit Flow is when the information subject to 'security classifications' is deduced indirectly. In this the leakage of information is through the program control flow. Depending on the flow of the program the secure information is compromised. 
A Pseudo Code Example: 
<code>PRIVATE VAR <big>secure</big> 
PUBLIC VAR <big>notsecure 
if secure="blah blah" then: 
insecure=1 
else: 
insecure=0</big> </code>
We can deduce if information in 'secure' is "blah blah" by checking the value of 'insecure'. Information leakage due to implicit flows are much harder to detect and protect from.

For more on Information Flow and its Math Model refer "A Lattice Model of Secure Information Flow" [1]
 '''<big>Taint Analysis</big>''' 

The main idea behind taint analysis is that any variable that can be modified directly or indirectly by the user and can become a security vulnerability is "tainted". The basic idea is that through various operations the "taint" can be passed from variable to variable and when a tainted variable is used to execute dangerous commands a security breach may occur. The basic premise of taint analysis is to identify these "tainted" variables and ensure that they do not create a security breach. 
Taint Analysis done at run-time is called as Dynamic Taint Analysis. The approach used in dynamic taint analysis is to label the data originating from untrusted sources as tainted. The analysis keeps track of all the tainted data in the memory and when such data is used in a dangerous situation, a possible bug is detected. This approach offers the capabilities to detect most of the input validation vulnerabilities with a very low false positive rate. However there are some disadvantages when using dynamic taint analysis. The execution of the program is slower because of the necessary additional checks. 
Static taint analysis is the technique used for detecting the overapproximation of the set of instructions that are influenced by user input. This set of tainted instructions is computed statically only by analyzing the sources of the program. The main advantage for static taint analysis is that it takes into account all the possible execution paths of the program. On the other hand the analysis may not be so accurate as the one performed dynamically because the static analyzer does not have access to the additional runtime information of the program. 

'''A Math Model:''' 
There are two types of variables
*Tainted
*Untainted
Thus V = {T,U} , T denotes "Tainted", U denotes "Untainted" 
Binary Operator <big>⊕</big>: V x V -> V 
<code><big>
x<big>⊕</big>y=T, if x = T OR y = T 
x<big>⊕</big>y=U, if x = y = U
</big></code> 
It is now intuitively easy to see that whenever a tainted variable is used it makes that variable tainted and thus the taint is propagated. Taking this further we can see that, if needed, we can tag variables as tainted by attaching to them a tainted tag, lets say "T'" which can then be tracked or used as wanted. 

Note: The paper talks about Dynamic Taint Analysis. TaintDroid makes ingenious use of "taint" to taint variables that are of value and tracks their progress. Though in the actual context of Taint Analysis "taint" is used for untrusted information however in this case the "taint" variables are infact important private data. (Just in case if it confused someone :D) For more detailed information on Taint Analysis refer "Detecting Software Vulnerabilities Static Taint Analysis"[2]

Explain briefly the background concepts and ideas that your fellow classmates will need to know first in order to understand your assigned paper.
* Background on the taint data tracking method, how it has been used in other systems (i.e. not phones)
* A reader's digest version of any new articles about this kind of security vulnerability on phones, on apps that collect more personal data than users would expect.

=Research problem=

In today’s society, smartphones are the new big thing. Smartphones, by their nature, are linked into many private details of our lives, including not only classic data like our contact list, but new kinds of data unique to smartphones, such as location data. Except for the odd tunnel or elevator, these phones are constantly connected to the internet. Smartphones also have the ability to download and run third party applications; indeed, this is why we call them "smart". When you combine third party applications with an internet connection, you suddenly find yourself unsure of how your data is being used, that is, what is to stop a third party application from disseminating our private information? As it turns out, very little.

A telling example of this is a wallpaper application that sends your phone number back to the developer. Once the app is running on your phone, it can typically access any of the information on your phone, and it is not necessarily clear when it has done so, or what it is doing with it.

The authors of this paper set out to try to understand what kind of information is being collected and where that information is being sent, and in order to do that, they first needed to build a means of tracking that information.

The strategy they chose is called Dynamic Taint Analysis, sometimes called Taint Tracking. The basic idea being to mark (''taint'') sensitive information at its source, and to then follow that mark as it moves through a system. In the context of this paper, if ever we should see marked data leave the network interface of the phone, then we know that some sensitive information has been disseminated.

There are many difficulties associated with implementing such a system on a smartphone. Their design goals were to create a light-weight, minimal overhead, real-time tracking system that runs directly on a real phone, with real applications. To be really useful, the tracking system must not impact the user experience too heavily.

Some of the difficulties include
* Smart phones are resource constrained. Processing power and memory are limited, and any processing that we do perform will consume battery power. If the tracking system is to be real-time, and for the phone to be considered "usable" by the end user, the system must be truly light weight.
* Third party applications arrive in a compiled format; we cannot analyze their source code.
* Applications may do complex things with the sensitive data. It is unlikely that the application will simply read a location from the GPS and dump it straight out over the network. More likely is that the application will use that data in someway, or combine it with other data, before it is sent. We need to be able to track sensitive data throughout this entire process if we hope to perform any useful analysis.
* Applications can share information with other applications, meaning that our tracking has to work across multiple processes.
* The tracking must operate on a real phone, not a simulated one. With a simulated system, where we control the virtual hardware and memory, we can be certain that we can see everything that an application might do. On a real device, how can we get "low enough" to see everything the applications do?

How does this problem relate to past related work?

=Contribution=
The contributions of the TaintDroid: An Information-Flow Tracking System for Realtime Privacy Monitoring on Smartphones paper is not that they achieved Information flow tracking but that they achieved it efficient enough to run in real time on real constrained hardware devices with minimal overheads. As stated "TaintDroid only incurs an approximate 14% CPU overhead and an approximate 4.4% memory overhead for simultaneously tracking 32 taint markings per data unit." It should also be noted that the 14% CPU over-head is only in regards to a "CPU-bound micro-benchmark and imposes negligible overhead on interactive third-party applications."

This is achieved by modifying the code directly at the VM layer of the Android system to provide variable-level tracking. This allows direct control over how and what private information, such as location details from the GPS, are stored and accessed. Next they modify the JNI layer to provide message-level tracking which allows them to monitor inter-process a.k.a. inter-application communications. This also allows them to "patch the taint propagation on return." so they can keep track of information transfer via native code. Finally modifying the network interface and secondary storage interfaces they are able to provide file-level taint tracking which enables them to ensure "persistent information conservatively retains its taint markings."

By combining these three levels (variable, message and file) of taint tracking, TaintDroid was able to effectively track 30 randomly selected popular 3rd party android applications. In doing so it correctly flagged 105 instances of tainted information transmission. Of these 105, only 35 were legitimate transfers. It also determined that 50% off the applications submitted the users location to advertising servers and 5 of the applications transmitted the users device ID, phone number and SIM card serial number.

The other contribution of TaintDorid is accuracy of tracking sensitive data. Unlike existing solutions that rely on heavy-weight whole-system emulation, the virtualized architecture of Android integrated four granularities of taint propagation:variable-level, method-level, message-level, and file-level. There are many factors influence the performance and accuracy of TaintDoroid. Taint tracking granularity and flow semantics are two of them. In the variable-level, TaintDorid treats the values at level. And the variables provide flow semantics for taint progagation to distinguish the different data pointers at different level to ensure the accuracy. Existing taint tracking approaches,like Panorama Taint System,rely on instruction-level dynamic taint analysis using whole system
emulation. This method leads to 2-20 times slowdown of system. Actually it's not suitable for the trend of realtime analysis. Moreover,instruction-level tracking faces a serious problem,taint explosion. When we use some complex instructions such as CMPXCHG, REP MOV,the stack pointer may become falsely tainted or taint loss. However,TaintDorid solved this problem with the combination of 4 levels.

From these outstanding numbers you can see that more effective higher granular permission systems are needed and TaintDroid is providing a step in the right direction, by providing a highly efficient real time tracking system.

=Critique=
What is good and not-so-good about this paper? You may discuss both the style and content; be sure to ground your discussion with specific references. Simple assertions that something is good or bad is not enough - you must explain why.

This paper has quite a bit of information and has a very strong structure in explaining what TaintDroid is and what it does. The sections begin as a high-level overview of TaintDroid, then explains the history followed by an explanation of sources that are tracked by TaintDroid and its design. It continues with test results and the strengths and weaknesses of TaintDroid, with references to related work. A proposed structure to improve the readability of the paper might be to explain what the background information of the Android phone is first before explaining the overview process of the TaintDroid. That way, the concepts of the paper would be easier to understand.

Did a good job in explaining the challenges in monitoring network disclosure of privacy sensitive information and how TaintDroid is successful despite these challenges
<ol>
<li>Smartphones are resource constrained</li>
<li>Third-party applications are entrusted with several types of privacy sensitive information</li>
<li>Context-based privacy sensitive information is dynamic and can be difficult to identify even when sent in the clear</li>
<li>Applications can share information</li>
</ol>

TaintDroid uses dynamic taint analysis to find a way around these challenges, using a taint source as the targeted sensitive information, and a taint marking to identify the information type. This paper discusses the strengths and weaknesses of the TaintDroid very effectively. The TaintDroid only tracks data flows and does not track control flows to minimize overhead. There are also other overhead issues due to the Taint Tag Storage, which is well explained due to the fact that most string objects all have the same tag. For this reason, it is possible for false positives to occur. By the test results and statistics of smartphones using TaintDroid, it is very obvious that personal information is often misused and that TaintDroid effectively identifies at a high percentage, the occurrence of this misuse. A possible improvement for this paper is the prediction of future smartphone security measures. This paper does a great job in explaining the TaintDroid, as well as related work in the security of personal information. Where this paper lacks is what changes could be made, or what possible updates to current programs can be implemented to further improve the results of tracking misuse of information, and even prevent it from occurring.

=References=
[1] DENNING, D. E. [http://www.cs.georgetown.edu/~denning/infosec/lattice76.pdf A Lattice Model of Secure Information Flow].
Communications of the ACM 19, 5 (May 1976), 236–243. 
[2]D CEARA, ML POTET et.al [http://tanalysis.googlecode.com/files/DumitruCeara_BSc.pdf Detecting Software Vulnerabilities Static Taint Analysis] GINP ENSIMAG GoogleCode(2009) 
[3] NEWSOME,J.,AND SONG,D. [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.2141&rep=rep1&type=pdf Dynamic Taint Analysis for Automatic Detection, Analysis, and Signature Generation of Exploits on Commodity Software] Proceedings of the Network and Distributed System Security Symposium (NDSS 2005)

Talk:COMP 3000 Essay 2 2010 Question 8

2010-11-24T16:39:28Z

Tmalone: /* Work In Progress */

Group Members

Trevor Bonesaw Malone - tmalone@connect.carleton.ca //FIRST POST!

Qi Zhang - qzhang13@connect.carleton.ca

Gregory Bint - gbint@connect.carleton.ca

Gautam Akiwate - gakiwate@connect.carleton.ca

==Relevant Sources==
*NEWSOME,J.,AND SONG,D.Dynamic Taint Analysis for Automatic Detection, Analysis, and Signature Generation of Exploits on Commodity Software. [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.2141&rep=rep1&type=pdf Dynamic Taint Analysis for Automatic Detection]
Seems to be THE Dynamic Taint Analysis Paper.Talks about implementation on TaintCheck. Could be also useful for critique section -[Gautam]

== Work Plan ==

As Trevor intimated, we should have clear division of work going forward. This is sort of the break down as I see it. Please edit as you think of new ideas!

* Background Concepts
** Information Flow Theory. (Implicit and Explicit Flows.)
** What is dynamic taint analysis
** What is the difference between dynamic and static analysis
* Research Problem
** How do we build a DTA engine for a phone?
** Why do we want to? (information misuse)
* Contribution
** How did they implement their DTA engine
** What did they find about information misuse
* Critique
* References
** The article has 61 references! We can probably use some of them

List of information we need to find external sources for:
* History of taint analysis
* History of privacy research relating to smart phones

== Work In Progress ==

Log what you are working on *right now* so that other people don't try to do the same thing. Make sure to clear your name from here when you are done.

* Gregory Bint: Research Problem
** I've got what you will hopefully find to be a reasonable introduction to the problem. I've tried to ask mostly questions here, expecting the details to be covered in Background Concepts and in Contributions.
** I'm going to try to find some history on smart phone security research for the second part.
** Should we move the Research Problem *above* Background Concepts? It might serve as a better lead in that way.

* Gautam Akiwate: Background Concepts
** Any resources on Dynamic taint Analysis would be appreciated!

* Qi Zhang: Contributions

* Trevor Malone: Critique

== Some Notes from the Video ==

Tracking of privacy sensitive data through Dynamic Taint Analysis (aka. Taint Tracking). The trick is to mark private data as it sourced, and then follow those marks until (unless) they leave the phone.

Android phones run Java apps, which are compiled into DEX, and then run on top of the Dalvik VM. It is this VM that we modify so that we can support the storage and tracking of taint tags.

Taint sources
* low -bandwidth sensors
** Location
** Accelerometer
* High-bandwidth sensors
** Mic
** Camera
* Information DB
** Address book
** SMS storage
* Device ID
** IMEI
** IMSI (don't actually track this one because of false positives)
** ICC_ID
** Phone Number

Taint sink (where marked data can leave the phone)
* Network Taint Sink

Taint propagation
* ???

Taint tags are stored in memory interleaved with the variables they are tracking

Some standard Data Flow technique is used to propagate these tags, especially as one variable that is marked may be assigned to another, so now that variable needs to be tracked as well.

Tracks explicit flows of data, not implicit
To fully capture implicit flows, you need to do static analysis, which is hard with closed-source apps, and cannot be done real-time

Implicit flows are not tracked
* Implicit flows can involve "taint-scope", tracking based on conditionals in code

=== Performance ===

The goal is to create a real time tracking system, so the TaintDroid's performance impact is of some importance

14% CPU overhead
4.4% memory overhead

Macro benchmarks (to get a feel for what the phone's usability is like with TD running)
* App load: 3% (2ms)

=== Findings ===

20 out of 30 tested applications share data in a way that is not expected.

67 of 105 flagged pieces of data leaving the device had no obviously legitimate purpose (verified by the authors).

Many apps sent location data and other unique identifiers to advertising servers.

Most apps do not mention anything to the user.

=== Limitations ===

Tracks only explicit data flows.

An application *could* launder the tags off of the data, if they really wanted to hide this sort of thing from TaintDroid.

There are methods that could be used to protect against this, but they go against the goal of a light-weight, real-time tracking system. TD is not necessarily about catching truly malicious programs, but rather just those that leak information.

Why do apps take this information?
* Lazy; in the demo video, the wallpaper app seems to use the IMEI just as a ready made unique ID
* Overzealous; the developer might thing they *need* the data for something, but actually
* Ads; advertises do seem a little presumptuous in their data collection
* Spying; bosses or spouses
* Malicious;

=== QA Period ===

Q: how do we prevent a malicious app from removing a taint attribute on a file

A: TD operates a too low a level for this to be a problem; TD assumes that the native code is trusted

Q: It seems like you had a lot of false positives

A: The point of this tool was to identify privacy sensitive information as having left the phone, not whether or not a privacy violation has taken place.

Q: Now that TD is released; couldn't malicious apps use some of the methods described in the paper to get around it?

A: Well, yes, but it is not just about maliciousness, it could just laziness or over-zealous ad stuff.

==Other Information==

Hey guys, thought I would just post a generalized paragraph about our essay.

In today’s society, Smartphones are the new big thing. To me that’s what makes this paper so interesting. This paper focuses on private information in android phones and the misuse of this information. The misuse of information includes the SIM card, the ID of the device, or the phone number. TaintDroid is used on smart phones with an efficient taint tracking and analysis system. It has the ability to track sensitive data from multiple sources and examines the misuse of such data. In their study, out of 80 popular third-party applications, TaintDroid monitored that 68 applications had potential misuse of user’s private data. This tool is great for knowing with applications are safe and which are not, so your private data can remained private.

Also, we should really think of splitting up the work in some way. If some people have specific sections they would like to do lets figure that out now so we can divide the workload and get it done over the next couple of days. I don't personally care what part I'm going to have to do, so lets get this going. Any other information people wanna post feel free the more the better, even if we don't end up using it.

[[user:Tmalone|Trevor Malone]]

Talk:COMP 3000 Essay 2 2010 Question 8

2010-11-22T15:34:25Z

Tmalone: /* Other Information */

Group Members

Trevor Bonesaw Malone - tmalone@connect.carleton.ca //FIRST POST!

Qi Zhang - qzhang13@connect.carleton.ca

Gregory Bint - gbint@connect.carleton.ca

Gautam Akiwate - gakiwate@connect.carleton.ca

== Some Notes from the Video ==

Tracking of privacy sensitive data through Dynamic Taint Analysis (aka. Taint Tracking). The trick is to mark private data as it sourced, and then follow those marks until (unless) they leave the phone.

Android phones run Java apps, which are compiled into DEX, and then run on top of the Dalvik VM. It is this VM that we modify so that we can support the storage and tracking of taint tags.

Taint sources
* low -bandwidth sensors
** Location
** Accelerometer
* High-bandwidth sensors
** Mic
** Camera
* Information DB
** Address book
** SMS storage
* Device ID
** IMEI
** IMSI (don't actually track this one because of false positives)
** ICC_ID
** Phone Number

Taint sink (where marked data can leave the phone)
* Network Taint Sink

Taint propagation
* ???

Taint tags are stored in memory interleaved with the variables they are tracking

Some standard Data Flow technique is used to propagate these tags, especially as one variable that is marked may be assigned to another, so now that variable needs to be tracked as well.

Tracks explicit flows of data, not implicit
To fully capture implicit flows, you need to do static analysis, which is hard with closed-source apps, and cannot be done real-time

Implicit flows are not tracked
* Implicit flows can involve "taint-scope", tracking based on conditionals in code

=== Performance ===

The goal is to create a real time tracking system, so the TaintDroid's performance impact is of some importance

14% CPU overhead
4.4% memory overhead

Macro benchmarks (to get a feel for what the phone's usability is like with TD running)
* App load: 3% (2ms)

=== Findings ===

20 out of 30 tested applications share data in a way that is not expected.

67 of 105 flagged pieces of data leaving the device had no obviously legitimate purpose (verified by the authors).

Many apps sent location data and other unique identifiers to advertising servers.

Most apps do not mention anything to the user.

=== Limitations ===

Tracks only explicit data flows.

An application *could* launder the tags off of the data, if they really wanted to hide this sort of thing from TaintDroid.

There are methods that could be used to protect against this, but they go against the goal of a light-weight, real-time tracking system. TD is not necessarily about catching truly malicious programs, but rather just those that leak information.

Why do apps take this information?
* Lazy; in the demo video, the wallpaper app seems to use the IMEI just as a ready made unique ID
* Overzealous; the developer might thing they *need* the data for something, but actually
* Ads; advertises do seem a little presumptuous in their data collection
* Spying; bosses or spouses
* Malicious;

=== QA Period ===

Q: how do we prevent a malicious app from removing a taint attribute on a file

A: TD operates a too low a level for this to be a problem; TD assumes that the native code is trusted

Q: It seems like you had a lot of false positives

A: The point of this tool was to identify privacy sensitive information as having left the phone, not whether or not a privacy violation has taken place.

Q: Now that TD is released; couldn't malicious apps use some of the methods described in the paper to get around it?

A: Well, yes, but it is not just about maliciousness, it could just laziness or over-zealous ad stuff.

===Other Information===

Hey guys, thought I would just post a generalized paragraph about our essay.

In today’s society, Smartphones are the new big thing. To me that’s what makes this paper so interesting. This paper focuses on private information in android phones and the misuse of this information. The misuse of information includes the SIM card, the ID of the device, or the phone number. TaintDroid is used on smart phones with an efficient taint tracking and analysis system. It has the ability to track sensitive data from multiple sources and examines the misuse of such data. In their study, out of 80 popular third-party applications, TaintDroid monitored that 68 applications had potential misuse of user’s private data. This tool is great for knowing with applications are safe and which are not, so your private data can remained private.

Also, we should really think of splitting up the work in some way. If some people have specific sections they would like to do lets figure that out now so we can divide the workload and get it done over the next couple of days. I don't personally care what part I'm going to have to do, so lets get this going. Any other information people wanna post feel free the more the better, even if we don't end up using it.

[[user:Tmalone|Trevor Malone]]

Talk:COMP 3000 Essay 2 2010 Question 8

2010-11-22T15:33:43Z

Tmalone: /* Some Notes from the Video */

Group Members

Trevor Bonesaw Malone - tmalone@connect.carleton.ca //FIRST POST!

Qi Zhang - qzhang13@connect.carleton.ca

Gregory Bint - gbint@connect.carleton.ca

Gautam Akiwate - gakiwate@connect.carleton.ca

== Some Notes from the Video ==

Tracking of privacy sensitive data through Dynamic Taint Analysis (aka. Taint Tracking). The trick is to mark private data as it sourced, and then follow those marks until (unless) they leave the phone.

Android phones run Java apps, which are compiled into DEX, and then run on top of the Dalvik VM. It is this VM that we modify so that we can support the storage and tracking of taint tags.

Taint sources
* low -bandwidth sensors
** Location
** Accelerometer
* High-bandwidth sensors
** Mic
** Camera
* Information DB
** Address book
** SMS storage
* Device ID
** IMEI
** IMSI (don't actually track this one because of false positives)
** ICC_ID
** Phone Number

Taint sink (where marked data can leave the phone)
* Network Taint Sink

Taint propagation
* ???

Taint tags are stored in memory interleaved with the variables they are tracking

Some standard Data Flow technique is used to propagate these tags, especially as one variable that is marked may be assigned to another, so now that variable needs to be tracked as well.

Tracks explicit flows of data, not implicit
To fully capture implicit flows, you need to do static analysis, which is hard with closed-source apps, and cannot be done real-time

Implicit flows are not tracked
* Implicit flows can involve "taint-scope", tracking based on conditionals in code

=== Performance ===

The goal is to create a real time tracking system, so the TaintDroid's performance impact is of some importance

14% CPU overhead
4.4% memory overhead

Macro benchmarks (to get a feel for what the phone's usability is like with TD running)
* App load: 3% (2ms)

=== Findings ===

20 out of 30 tested applications share data in a way that is not expected.

67 of 105 flagged pieces of data leaving the device had no obviously legitimate purpose (verified by the authors).

Many apps sent location data and other unique identifiers to advertising servers.

Most apps do not mention anything to the user.

=== Limitations ===

Tracks only explicit data flows.

An application *could* launder the tags off of the data, if they really wanted to hide this sort of thing from TaintDroid.

There are methods that could be used to protect against this, but they go against the goal of a light-weight, real-time tracking system. TD is not necessarily about catching truly malicious programs, but rather just those that leak information.

Why do apps take this information?
* Lazy; in the demo video, the wallpaper app seems to use the IMEI just as a ready made unique ID
* Overzealous; the developer might thing they *need* the data for something, but actually
* Ads; advertises do seem a little presumptuous in their data collection
* Spying; bosses or spouses
* Malicious;

=== QA Period ===

Q: how do we prevent a malicious app from removing a taint attribute on a file

A: TD operates a too low a level for this to be a problem; TD assumes that the native code is trusted

Q: It seems like you had a lot of false positives

A: The point of this tool was to identify privacy sensitive information as having left the phone, not whether or not a privacy violation has taken place.

Q: Now that TD is released; couldn't malicious apps use some of the methods described in the paper to get around it?

A: Well, yes, but it is not just about maliciousness, it could just laziness or over-zealous ad stuff.

===Other Information===

Hey guys, thought I would just post a generalized paragraph about our essay.

In today’s society, Smartphones are the new big thing. To me that’s what makes this paper so interesting. This paper focuses on private information in android phones and the misuse of this information. The misuse of information includes the SIM card, the ID of the device, or the phone number. TaintDroid is used on smart phones with an efficient taint tracking and analysis system. It has the ability to track sensitive data from multiple sources and examines the misuse of such data. In their study, out of 80 popular third-party applications, TaintDroid monitored that 68 applications had potential misuse of user’s private data. This tool is great for knowing with applications are safe and which are not, so your private data can remained private.

Also, we should really think of splitting up the work in some way. If some people have specific sections they would like to do lets figure that out now so we can divide the workload and get it done over the next couple of days. I don't personally care what part I'm going to have to do, so lets get this going. Any other information people wanna post feel free the more the better, even if we don't end up using it.

User:Tmalone

2010-11-16T15:22:14Z

Tmalone: Blanked the page

Talk:COMP 3000 Essay 2 2010 Question 8

2010-11-16T15:11:18Z

Tmalone: Created page with "Group Members Trevor Bonesaw Malone - tmalone@connect.carleton.ca //FIRST POST!"

Group Members

Trevor Bonesaw Malone - tmalone@connect.carleton.ca //FIRST POST!

Talk:COMP 3000 Essay 1 2010 Question 8

2010-10-15T00:10:39Z

Tmalone: /* Discussion */

== Group 8 ==

'''GROUP NAMES:'''

Niravkumar Patel (Npatel1)

Trevor Malone (Tmalone)

Mark Walts (Rift)

John Vanden Heuvel (jvheuvel)

Jeff Francom (Afranco2)

==Question clarification==

To answer this question properly you need to discuss where pthreads came from. The UNIX process model came out in the early 1970's, pthreads was only really proposed in the late 1980's. That's 10-15 years of history, what was happening? What about the general development of threads in CS? Alternative pthread implementations (who had the first one? what was the first kernel-based one?). I know that the history of pthreads on linux is kind of complicated - see the [http://en.wikipedia.org/wiki/Native_POSIX_Thread_Library NPTL]. You don't need to talk about all of this - but you do need to go beyond just what happened with the pthread standard. --[[User:Soma|Anil]]

----

Thank you prof. Anil, we'll look into those questions in depth and edit our essay.
--[[User: Npatel1|Npatel1]]

----

- UNIX was born in 1969

- Began on a PDP-11/20 machine with a text formatting program called roff and a text editor

- Was rewritten in C in 1972 -> brought forth more portable software

- Became available to Universities and commercial firms as well as the US Government

- Many editions of UNIX came out, by 1975 Versions 4, 5, and 6 were released

- The new versions added the concept of pipes -> led to more modular code-base and faster development cycle

- Pipeline is a chain of processes together by streams, so that the output of one process is the input of the next

- Became more and more portable

- In 1979, UNIX Version 7 was released

- Several more Versions 8, 9, and 10 released the in 80's

- Early UNIX had a 'process', which was essentially a thread of control, with a virtual address space

- Interacted through pipes because they could not share

- After a while, UNIX wanted processes that shared memory, bringing the invention of the thread

- Also called lightweight in contrast to the heavyweight processes before it

- This is dated around the late 1970's and the early 80's, and example is the microkernel

- Alternative Pthread implementation in the 4.0 Digital UNIX, known as DEC OSF/1
- It was a part of the Mach OS

- Pthread library schedules threads at a one-to-one relationship, all threads fight other threads, not threads of the same process.

- Good for priority, if priority is increased, so is the function of the specific process

- Doesn't limit a program to a single executing thread, many threads in a program can run on different CPU's

- NPTL (Native POSIX Thread Library) is software that enables the Linux kernel to run programs using POSIX threads efficiently

- Has become a part of the Linux kernel since Version 2.6 (Version 1 began around 1996)

- Was a massive improvement from LinuxThreads, which had no real support for threads

- NPTL was first released in Red Hat Linux 9

- Threads are still created with clone() system call and futex primitive is used to implement locking

----

http://en.wikipedia.org/wiki/Pipeline_%28Unix%29

http://en.wikipedia.org/wiki/Unix#1970s

http://books.google.ca/books?id=EZfElJsWCqgC&pg=PA198&lpg=PA198&dq=kernel+based+pthreads&source=bl&ots=3HFKw_0nqq&sig=P0L9feIb88xJRzQfLd7maKtVnTU&hl=en&ei=Oky3TM-_OaO0nAf1-YiwCA&sa=X&oi=book_result&ct=result&resnum=6&ved=0CCsQ6AEwBQ#v=onepage&q=kernel%20based%20pthreads&f=false

http://en.wikipedia.org/wiki/Native_POSIX_Thread_Library

http://www.faqs.org/faqs/os-research/part1/section-10.html

- Tmalone

----

That's great! Nice work Trevor, I'll get started on the paragraph that answers Prof's questions with the help of your notes. Hopefully have it done before 12! So you guys can check the essay again. (also if anyone wishes to give me a hand in with this portion of the essay, please do so under "Unsorted").

Hey, Rift...upon finishing the prof's requirement, can you please add footnotes? I'm unaware of how it's done. Thanks.

--[[User: Npatel1|Npatel1]]

----

yea i can add the footnote/reference stuff to the paragraphs you post. [[User:Rift|Rift]] 21:55, 14 October 2010 (UTC)

----

thanks Mark, I'll hopefully have the requirements done by 12ish. --[[User:Npatel1|Npatel1]]

----

==Unsorted==
(unsorted essay)

-[[User:Npatel1|Npatel1]] ; here is the first paragraph. you can edit/add more to the paragraph if needed!

-Afranco2; I put in the history section/strung in tmalone's stuff as well. Again, feel free to edit/add content

-Tmalone; Edited and corrected the information thus far. I will post a conclusion sometime tomorrow.

-[[User:Npatel1|Npatel1]] ; Trevor, last lines should get us started on the conclusion. Afranco2; i went to class today and prof. was talking about plagiarism, can you please check your paragraph and see if there is any signs of plagiarism. since i don't know where you gathered your information from. upon you completion please post on wiki; need to make some modification to the body paragraph.

-http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=6626986821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091 That is one of the sources which I used for my information. I don't believe that I am plagiarizing, but I know that it is easy to do accidentally. If somebody wants to check it over for me to make sure, that would be great. My information comes from the first and second page. I also used POSIX Threads and the Linux Kernel and a little bit from IEEE POSIX Testing Policy General Information

-[[User:Npatel1|Npatel1]] ; oh i just wanted to make sure since the prof. emphasized on it a lot last class! thanks Afranco2.

POSIX (Portable Operating System Interface) threads, are high performance threads mainly distributed in UNIX but also to some Microsoft Windows OSes. Threads are used in parallel programming; when a system call executes, the thread runs on an independent stream to finish its task with minimal interruptions or slowdowns. Pthreads (from POSIX threads) are ideal for massive modifications to programs because the threads share one single memory space to alter a data structure, allowing constant high performance and efficiency. Pthreads have become a commonly used way of adding concurrency to an application. They are widely used in UNIX; a powerful operating system written in the C language, which is continuously enhanced. Developers came across various obstacles with POSIX threads; during the beginnings of Pthreads, many technical issues had surfaced which were resolved throughout the history of POSIX threads.

The history of POSIX Threads is that many hardware sellers executed their own versions of threads. These developments differed from one another, creating difficulties for programmers to implement portable thread applications. UNIX traditionally had a system running only a single thread under a process. These processes could not share memory and interacted using 'pipes'. Once developers started wanting to be able to run multiple threads under one process, IEEE began to form together the POSIX standards. In 1988 POSIX.1 (created to support application portability) was ratified and was accepted as the international standard in 1990. From there the POSIX standards grew to more than 20 individual standards, encapsulating a large area of different groups.

POSIX.1 lays out the interfaces for OS services; their syntax, and how they should act. It however does not define how the interface should be implemented on the OS. This is made to allow many different operating systems to conform to standards in their own specific design and application. POSIX.2 was created for much the same reason as POSIX.1 (portable shell programming, portable program development) but describes a programmable shell and its common utilities.

POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto Linux; this is due to the significant differences in relationship between POSIX and UNIX.

^^^ this statement sounds a bit off. why does UNIX care what Linux can handle? - John v.

I'll look into that tomorrow; working on 3005 Assignment. John, if you have a suggestion or an add-on that you wish to provide, please do so under collaboration.

-[[User:Npatel1|Npatel1]]

Hey guys, before end of tomorrow if there is anything missing or if anyone wishes to contribute more towards the essay please do so asap.

-[[User:Npatel1|Npatel1]]

UNIX cares about what Linux can handle because POSIX threads are mainly used in Linux systems. It is a very big deal if a certain type of thread is generating countless errors on the main system type the thread is created for. And regardless of just the fact that its widely used on Linux, UNIX would care because compatibility is one of the most important things to have. For a POSIX thread to not be compatible with Linux just because UNIX didn't care, then the progress of multi-threading and POSIX threads would not be able to be used in Linux. Then Linux would not be as widely used as it would not be enhanced like other systems. It is important for systems to have that compatibility, so that they don't end up left in the dust of technology.

-[[User:Tmalone|Tmalone]]

----

One of the major reasons why UNIX was so late to implement support for the POSIX threads is the way the two define "multi-threaded" process.
Traditionally UNIX defined a process to be an instance of a running program.With POSIX this came to be defined more precisely. The 'process'
was defined to be "an address-space and a group of resources dedicated to running the program". 
POSIX defines a 'thread' as the resources neccessary for a single thread of execution ie. a single execution path. Thus according to POSIX the basic unit of execution is a thread. On the other hand UNIX traditionally defined a 'task' as the basic unit of execution which is essentially same as the POSIX definition of a 'process'. 
Now the conflict between the POSIX Threads and UNIX implementation of tasks came when a task used a clone() system call to create another task in order to implement multi-threading. The program then becomes a co-operating set of tasks which share 'some' resources. It is due to this halfway implementation of sharing of resources that lies the major conflict. In a nutshell the fundamental difference between the two is that in POSIX a process can be addressed as a single entity, while in Linux it is a collection of independent tasks. In the POSIX thread implementation all actions affect the entire process. In Linux, however, each of these actions will only affect one task.

Not from your group. But I think your essay should incorporate this too. --[[User:Gautam|Gautam]] 19:35, 14 October 2010 (UTC)

Appreciate your contribution towards the essay even though your not in our group; if its possible, can you please give us the link to which you got the information from. --[[User:Npatel1|Npatel1]]

== Discussion ==

----

[http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf POSIX Threads and the Linux Kernel] --[[User:Gautam|Gautam]] 23:52, 5 October 2010 (UTC)

Not from your group. However I found a webpage which you might find useful.
[http://www.drdobbs.com/open-source/184406204;jsessionid=3MRSO5YMO1QVRQE1GHRSKHWATMY32JVN The New Implementation of Threads for Linux]
--[[User:Gautam|Gautam]] 22:56, 5 October 2010 (UTC)

----

Not extremely helpful but: [http://www.unix.com/unix-dummies-questions-answers/7-short-history-unix-l-madden-ic-ac-uk.html A short history of unix] [[User:Rift|Rift]] 18:30, 7 October 2010 (UTC)

----

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf IEEE POSIX Testing Policy General Information
The POSIX family of standards, Stephen R. Walli
-afranco2

I'm not sure how we are planning on structuring this essay, but I will just write a bit on the history of Posix part for now. Does somebody want to handle writing an intro? - afranco2

----

Hey guys, sorry for the late reply...
i just wanted everyone to finish their assignment portion. we would have our own set of explanation for question 8.

AFRANCO2; Here is a suggestion.

1st paragraph;
should consist defining UNIX and POSIX/Threads

2nd paragrah;
consisting the history behind POSIX and why UNIX was so late to implement the support of multithreaded processes.

3rd paragraph;
should conclude it all.

I agree, but I don't think that we should limit it to specifically 'paragraphs' but rather sections. -afranco2

Here is a site that would take care of paragraph 1:
https://computing.llnl.gov/tutorials/pthreads/

GAUTHAM provided us with very useful pdf. that talks about the history of POSIX.

-[[User:Npatel1|Npatel1]]

----

This may be a stupid question, buy does anybody know what we have to do for citation? Are we using footnotes like a regular wiki? Or is there another conformation we need to follow? -afranco2

--footnotes are probably easiest, John v.

I'll take care of the first paragraph if you guys are comfortable with the structure of the essay (post it by the end of today). since we already have AFRANCO2 who did the history portion of the essay.

I made a new tab for "ESSAY" final copy*

-[[User:Npatel1|Npatel1]]

I'm not sure about the citations; just keep the links you used to gather the information, we'll ask him on Tuesday.
(i was just wondering, is this is the kind of structure you were looking for? or should we change the structure?)

-[[User:Npatel1|Npatel1]]

----

So what all do we need left? Sorry I am out of town trying to keep up as much as possible. Ive posted my research content on the primary page. And I've noticed we are getting pretty organized with our essay format. Just as an update process what has been completed and what is left to do? Because i don't wanna type up a bunch of information we may not need anymore. So Whatever else we need I can type up with all our info and then we can out the together the essay in the next couple days.

- Tmalone

And I think the structure is a good idea. We have enough information to turn it all into a good essay. If you have another suggestion on the structure though by all means tell us what you think.

- Tmalone

sounds good! I'm sorry i was unable to post the Intro today...
I'll make sure to have it by tomorrow!

----

Tmalone, i think we have good portion for History; i will get us started with a good intro then link in the history as our second paragraph which afranco2 has provided. then we'll talk about why UNIX was soo late; finally conclude it all with a last paragraph.

-[[User:Npatel1|Npatel1]]

----

Alright, I'll get started on a possible conclusion format. Then we can post it all and edit and add/delete whatever we want. So then hopefully by Tuesdays class we will have a good make-up of the essay we want.

- Tmalone

I read the current essay format posted. It was really well done good job guys. I read over it and corrected some minor grammar errors. So by sometime tomorrow I'll have a possible conclusion paragraph posted. If anyone else wants to type anything up for a conclusion they can feel free to as well! The more the better.

- Tmalone

----

It's looking good. Sorry if i'm a bit late to the party. I threw a paragraph down in the answer part. I know it doesn't really fit well.. but it really nees to get worked in.. -Rift

----

little late here too, got sidetracked with 3004 and 3008. I do have a concern in that 3 paragraphs really isn't an essay, he seemed to want more than that JOhn v.

----

anyone remember what was cited where in the essay? we're still missing references -- John

----

yeah, Tmalone decided that he was going to do the citation suitable to the essay. Feel free to help; upon finishing, we'll post it on the "page". Nothing fancy, Prof. Anil mentioned that he just wanted the basic format. John, the information that was cited is in discussion and also in collaboration. -

----

I cited a few things and added a small paragraph. It's really hard to find things/events relating to it.. [[User:Rift|Rift]] 15:12, 14 October 2010 (UTC)

----

Hey guys I created the citations for all of our resources, Its all posted in the references tab on the main page. If i missed something feel gfree to add it using the same format as I did, im pretty sure i covered it all though

- [[User:Tmalone|Tmalone]]

== Sources ==

Everyone please post any extra links here;
we'll organize it after everyone posts their links.

posted the ones that are provided on our discussion.

-[[User:Npatel1|Npatel1]]

http://www.unix.org/whitepapers/shdiffs.html

http://en.wikipedia.org/wiki/POSIX_Threads

http://sourceware.org/pthreads-win32/

https://computing.llnl.gov/tutorials/pthreads/

http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf

http://www.drdobbs.com/open-source/184406204;jsessionid=GKSVKT3EOMUBDQE1GHRSKHWATMY32JVN

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf

http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=6626986821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091

Journal article "Achieving Efficiency and Portability in Systems Software: A Case Study on POSIX-Compliant Multithreaded Programs" http://dx.doi.org.proxy.library.carleton.ca/10.1109/TSE.2005.98

Talk:COMP 3000 Essay 1 2010 Question 8

2010-10-15T00:10:15Z

Tmalone: /* Discussion */

== Group 8 ==

'''GROUP NAMES:'''

Niravkumar Patel (Npatel1)

Trevor Malone (Tmalone)

Mark Walts (Rift)

John Vanden Heuvel (jvheuvel)

Jeff Francom (Afranco2)

==Question clarification==

To answer this question properly you need to discuss where pthreads came from. The UNIX process model came out in the early 1970's, pthreads was only really proposed in the late 1980's. That's 10-15 years of history, what was happening? What about the general development of threads in CS? Alternative pthread implementations (who had the first one? what was the first kernel-based one?). I know that the history of pthreads on linux is kind of complicated - see the [http://en.wikipedia.org/wiki/Native_POSIX_Thread_Library NPTL]. You don't need to talk about all of this - but you do need to go beyond just what happened with the pthread standard. --[[User:Soma|Anil]]

----

Thank you prof. Anil, we'll look into those questions in depth and edit our essay.
--[[User: Npatel1|Npatel1]]

----

- UNIX was born in 1969

- Began on a PDP-11/20 machine with a text formatting program called roff and a text editor

- Was rewritten in C in 1972 -> brought forth more portable software

- Became available to Universities and commercial firms as well as the US Government

- Many editions of UNIX came out, by 1975 Versions 4, 5, and 6 were released

- The new versions added the concept of pipes -> led to more modular code-base and faster development cycle

- Pipeline is a chain of processes together by streams, so that the output of one process is the input of the next

- Became more and more portable

- In 1979, UNIX Version 7 was released

- Several more Versions 8, 9, and 10 released the in 80's

- Early UNIX had a 'process', which was essentially a thread of control, with a virtual address space

- Interacted through pipes because they could not share

- After a while, UNIX wanted processes that shared memory, bringing the invention of the thread

- Also called lightweight in contrast to the heavyweight processes before it

- This is dated around the late 1970's and the early 80's, and example is the microkernel

- Alternative Pthread implementation in the 4.0 Digital UNIX, known as DEC OSF/1
- It was a part of the Mach OS

- Pthread library schedules threads at a one-to-one relationship, all threads fight other threads, not threads of the same process.

- Good for priority, if priority is increased, so is the function of the specific process

- Doesn't limit a program to a single executing thread, many threads in a program can run on different CPU's

- NPTL (Native POSIX Thread Library) is software that enables the Linux kernel to run programs using POSIX threads efficiently

- Has become a part of the Linux kernel since Version 2.6 (Version 1 began around 1996)

- Was a massive improvement from LinuxThreads, which had no real support for threads

- NPTL was first released in Red Hat Linux 9

- Threads are still created with clone() system call and futex primitive is used to implement locking

----

http://en.wikipedia.org/wiki/Pipeline_%28Unix%29

http://en.wikipedia.org/wiki/Unix#1970s

http://books.google.ca/books?id=EZfElJsWCqgC&pg=PA198&lpg=PA198&dq=kernel+based+pthreads&source=bl&ots=3HFKw_0nqq&sig=P0L9feIb88xJRzQfLd7maKtVnTU&hl=en&ei=Oky3TM-_OaO0nAf1-YiwCA&sa=X&oi=book_result&ct=result&resnum=6&ved=0CCsQ6AEwBQ#v=onepage&q=kernel%20based%20pthreads&f=false

http://en.wikipedia.org/wiki/Native_POSIX_Thread_Library

http://www.faqs.org/faqs/os-research/part1/section-10.html

- Tmalone

----

That's great! Nice work Trevor, I'll get started on the paragraph that answers Prof's questions with the help of your notes. Hopefully have it done before 12! So you guys can check the essay again. (also if anyone wishes to give me a hand in with this portion of the essay, please do so under "Unsorted").

Hey, Rift...upon finishing the prof's requirement, can you please add footnotes? I'm unaware of how it's done. Thanks.

--[[User: Npatel1|Npatel1]]

----

yea i can add the footnote/reference stuff to the paragraphs you post. [[User:Rift|Rift]] 21:55, 14 October 2010 (UTC)

----

thanks Mark, I'll hopefully have the requirements done by 12ish. --[[User:Npatel1|Npatel1]]

----

==Unsorted==
(unsorted essay)

-[[User:Npatel1|Npatel1]] ; here is the first paragraph. you can edit/add more to the paragraph if needed!

-Afranco2; I put in the history section/strung in tmalone's stuff as well. Again, feel free to edit/add content

-Tmalone; Edited and corrected the information thus far. I will post a conclusion sometime tomorrow.

-[[User:Npatel1|Npatel1]] ; Trevor, last lines should get us started on the conclusion. Afranco2; i went to class today and prof. was talking about plagiarism, can you please check your paragraph and see if there is any signs of plagiarism. since i don't know where you gathered your information from. upon you completion please post on wiki; need to make some modification to the body paragraph.

-http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=6626986821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091 That is one of the sources which I used for my information. I don't believe that I am plagiarizing, but I know that it is easy to do accidentally. If somebody wants to check it over for me to make sure, that would be great. My information comes from the first and second page. I also used POSIX Threads and the Linux Kernel and a little bit from IEEE POSIX Testing Policy General Information

-[[User:Npatel1|Npatel1]] ; oh i just wanted to make sure since the prof. emphasized on it a lot last class! thanks Afranco2.

POSIX (Portable Operating System Interface) threads, are high performance threads mainly distributed in UNIX but also to some Microsoft Windows OSes. Threads are used in parallel programming; when a system call executes, the thread runs on an independent stream to finish its task with minimal interruptions or slowdowns. Pthreads (from POSIX threads) are ideal for massive modifications to programs because the threads share one single memory space to alter a data structure, allowing constant high performance and efficiency. Pthreads have become a commonly used way of adding concurrency to an application. They are widely used in UNIX; a powerful operating system written in the C language, which is continuously enhanced. Developers came across various obstacles with POSIX threads; during the beginnings of Pthreads, many technical issues had surfaced which were resolved throughout the history of POSIX threads.

The history of POSIX Threads is that many hardware sellers executed their own versions of threads. These developments differed from one another, creating difficulties for programmers to implement portable thread applications. UNIX traditionally had a system running only a single thread under a process. These processes could not share memory and interacted using 'pipes'. Once developers started wanting to be able to run multiple threads under one process, IEEE began to form together the POSIX standards. In 1988 POSIX.1 (created to support application portability) was ratified and was accepted as the international standard in 1990. From there the POSIX standards grew to more than 20 individual standards, encapsulating a large area of different groups.

POSIX.1 lays out the interfaces for OS services; their syntax, and how they should act. It however does not define how the interface should be implemented on the OS. This is made to allow many different operating systems to conform to standards in their own specific design and application. POSIX.2 was created for much the same reason as POSIX.1 (portable shell programming, portable program development) but describes a programmable shell and its common utilities.

POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto Linux; this is due to the significant differences in relationship between POSIX and UNIX.

^^^ this statement sounds a bit off. why does UNIX care what Linux can handle? - John v.

I'll look into that tomorrow; working on 3005 Assignment. John, if you have a suggestion or an add-on that you wish to provide, please do so under collaboration.

-[[User:Npatel1|Npatel1]]

Hey guys, before end of tomorrow if there is anything missing or if anyone wishes to contribute more towards the essay please do so asap.

-[[User:Npatel1|Npatel1]]

UNIX cares about what Linux can handle because POSIX threads are mainly used in Linux systems. It is a very big deal if a certain type of thread is generating countless errors on the main system type the thread is created for. And regardless of just the fact that its widely used on Linux, UNIX would care because compatibility is one of the most important things to have. For a POSIX thread to not be compatible with Linux just because UNIX didn't care, then the progress of multi-threading and POSIX threads would not be able to be used in Linux. Then Linux would not be as widely used as it would not be enhanced like other systems. It is important for systems to have that compatibility, so that they don't end up left in the dust of technology.

-[[User:Tmalone|Tmalone]]

----

One of the major reasons why UNIX was so late to implement support for the POSIX threads is the way the two define "multi-threaded" process.
Traditionally UNIX defined a process to be an instance of a running program.With POSIX this came to be defined more precisely. The 'process'
was defined to be "an address-space and a group of resources dedicated to running the program". 
POSIX defines a 'thread' as the resources neccessary for a single thread of execution ie. a single execution path. Thus according to POSIX the basic unit of execution is a thread. On the other hand UNIX traditionally defined a 'task' as the basic unit of execution which is essentially same as the POSIX definition of a 'process'. 
Now the conflict between the POSIX Threads and UNIX implementation of tasks came when a task used a clone() system call to create another task in order to implement multi-threading. The program then becomes a co-operating set of tasks which share 'some' resources. It is due to this halfway implementation of sharing of resources that lies the major conflict. In a nutshell the fundamental difference between the two is that in POSIX a process can be addressed as a single entity, while in Linux it is a collection of independent tasks. In the POSIX thread implementation all actions affect the entire process. In Linux, however, each of these actions will only affect one task.

Not from your group. But I think your essay should incorporate this too. --[[User:Gautam|Gautam]] 19:35, 14 October 2010 (UTC)

Appreciate your contribution towards the essay even though your not in our group; if its possible, can you please give us the link to which you got the information from. --[[User:Npatel1|Npatel1]]

== Discussion ==

----

[http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf POSIX Threads and the Linux Kernel] --[[User:Gautam|Gautam]] 23:52, 5 October 2010 (UTC)

Not from your group. However I found a webpage which you might find useful.
[http://www.drdobbs.com/open-source/184406204;jsessionid=3MRSO5YMO1QVRQE1GHRSKHWATMY32JVN The New Implementation of Threads for Linux]
--[[User:Gautam|Gautam]] 22:56, 5 October 2010 (UTC)

----

Not extremely helpful but: [http://www.unix.com/unix-dummies-questions-answers/7-short-history-unix-l-madden-ic-ac-uk.html A short history of unix] [[User:Rift|Rift]] 18:30, 7 October 2010 (UTC)

----

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf IEEE POSIX Testing Policy General Information
The POSIX family of standards, Stephen R. Walli
-afranco2

I'm not sure how we are planning on structuring this essay, but I will just write a bit on the history of Posix part for now. Does somebody want to handle writing an intro? - afranco2

----

Hey guys, sorry for the late reply...
i just wanted everyone to finish their assignment portion. we would have our own set of explanation for question 8.

AFRANCO2; Here is a suggestion.

1st paragraph;
should consist defining UNIX and POSIX/Threads

2nd paragrah;
consisting the history behind POSIX and why UNIX was so late to implement the support of multithreaded processes.

3rd paragraph;
should conclude it all.

I agree, but I don't think that we should limit it to specifically 'paragraphs' but rather sections. -afranco2

Here is a site that would take care of paragraph 1:
https://computing.llnl.gov/tutorials/pthreads/

GAUTHAM provided us with very useful pdf. that talks about the history of POSIX.

-[[User:Npatel1|Npatel1]]

----

This may be a stupid question, buy does anybody know what we have to do for citation? Are we using footnotes like a regular wiki? Or is there another conformation we need to follow? -afranco2

--footnotes are probably easiest, John v.

I'll take care of the first paragraph if you guys are comfortable with the structure of the essay (post it by the end of today). since we already have AFRANCO2 who did the history portion of the essay.

I made a new tab for "ESSAY" final copy*

-[[User:Npatel1|Npatel1]]

I'm not sure about the citations; just keep the links you used to gather the information, we'll ask him on Tuesday.
(i was just wondering, is this is the kind of structure you were looking for? or should we change the structure?)

-[[User:Npatel1|Npatel1]]

----

So what all do we need left? Sorry I am out of town trying to keep up as much as possible. Ive posted my research content on the primary page. And I've noticed we are getting pretty organized with our essay format. Just as an update process what has been completed and what is left to do? Because i don't wanna type up a bunch of information we may not need anymore. So Whatever else we need I can type up with all our info and then we can out the together the essay in the next couple days.

- Tmalone

And I think the structure is a good idea. We have enough information to turn it all into a good essay. If you have another suggestion on the structure though by all means tell us what you think.

- Tmalone

sounds good! I'm sorry i was unable to post the Intro today...
I'll make sure to have it by tomorrow!

----

Tmalone, i think we have good portion for History; i will get us started with a good intro then link in the history as our second paragraph which afranco2 has provided. then we'll talk about why UNIX was soo late; finally conclude it all with a last paragraph.

-[[User:Npatel1|Npatel1]]

----

Alright, I'll get started on a possible conclusion format. Then we can post it all and edit and add/delete whatever we want. So then hopefully by Tuesdays class we will have a good make-up of the essay we want.

- Tmalone

I read the current essay format posted. It was really well done good job guys. I read over it and corrected some minor grammar errors. So by sometime tomorrow I'll have a possible conclusion paragraph posted. If anyone else wants to type anything up for a conclusion they can feel free to as well! The more the better.

- Tmalone

----

It's looking good. Sorry if i'm a bit late to the party. I threw a paragraph down in the answer part. I know it doesn't really fit well.. but it really nees to get worked in.. -Rift

----

little late here too, got sidetracked with 3004 and 3008. I do have a concern in that 3 paragraphs really isn't an essay, he seemed to want more than that JOhn v.

----

anyone remember what was cited where in the essay? we're still missing references -- John

----

yeah, Tmalone decided that he was going to do the citation suitable to the essay. Feel free to help; upon finishing, we'll post it on the "page". Nothing fancy, Prof. Anil mentioned that he just wanted the basic format. John, the information that was cited is in discussion and also in collaboration. -[[User:Npatel1|Npatel1]]

----

I cited a few things and added a small paragraph. It's really hard to find things/events relating to it.. [[User:Rift|Rift]] 15:12, 14 October 2010 (UTC)

----

Hey guys I created the citations for all of our resources, Its all posted in the references tab on the main page. If i missed something feel gfree to add it using the same format as I did, im pretty sure i covered it all though

== Sources ==

Everyone please post any extra links here;
we'll organize it after everyone posts their links.

posted the ones that are provided on our discussion.

-[[User:Npatel1|Npatel1]]

http://www.unix.org/whitepapers/shdiffs.html

http://en.wikipedia.org/wiki/POSIX_Threads

http://sourceware.org/pthreads-win32/

https://computing.llnl.gov/tutorials/pthreads/

http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf

http://www.drdobbs.com/open-source/184406204;jsessionid=GKSVKT3EOMUBDQE1GHRSKHWATMY32JVN

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf

http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=6626986821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091

Journal article "Achieving Efficiency and Portability in Systems Software: A Case Study on POSIX-Compliant Multithreaded Programs" http://dx.doi.org.proxy.library.carleton.ca/10.1109/TSE.2005.98

COMP 3000 Essay 1 2010 Question 8

2010-10-15T00:08:55Z

Tmalone: /* References */

=Question=

What is the history of POSIX Threads (pthreads)? Consider - does this history explain why UNIX was so late to implement support for multithreaded processes?

=Essay=

-[[User:Npatel1|Npatel1]] ; here is the final copy guys, feel free to edit the essay under "Unsorted". if it requires major changes please post a note in discussion board, cheers.

-Started throwing in some citation links. Some are duplicates because I'm not sure how to really do them correctly (kind of a wiki noob) -Afranco2

-[[User:Npatel1|Npatel1]] ; working on UNIX, Treads/Pthreads. (adding the answers to addition questions) will be done around 12-1AM.

----

==Introduction==

'''POSIX threads, also known as Portable Operating System Interface, are high performance threads mainly distributed in UNIX but also to some Microsoft Windows OS. Threads are used in parallel programming; when a system call executes, the thread runs on an independent stream to finish its task with minimal interruptions or slowdowns. Pthreads are ideal for massive modifications to programs because the threads share one single memory space to alter a data structure, allowing constant high performance and efficiency. Pthread has become commonly used a way of adding concurrency to an application. They are widely used in UNIX; a powerful operating system written in the C language, which is continuously enhanced. Developers came across various obstacles with POSIX threads; during the beginnings of Pthreads, many technical issues had surfaced which were resolved throughout the history of POSIX threads.'''

==History==

===UNIX===
(working on it)

===Threads/Pthreads===

'''The notion of threads developed naturally out of the desire for processes to communicate with each other. Threads are at a basic level multiple threads of control that share memory, and sharing memory is a relatively instantaneous method of communication. In UNIX where processes were seen as needed on a 1:1 per-terminal basis, and more about time-sharing then working together, at first this seemed relatively unnecessary[http://tinf2.vub.ac.be/~dvermeir/manuals/KDE20Development-html/ch13lev1sec2.html]. Retrieved on October 14 2010</ref>. There were after all, mechanisms in place to communicate between processes such as pipes and temporary files as well as a few "just changed" messages. The first UNIX implementation of shared memory came about in 1983 with the System V UNIX flavor, which shared memory was merely one of several upgrades to passing messages between processes.[http://fscked.org/writings/SHM/shm-5.html]'''

===Complications===

'''The beginning of POSIX Threads starts off with hardware sellers executing their own versions of threads[https://computing.llnl.gov/tutorials/pthreads/]. These developments varied from one another, creating difficulties for programmers to implement portable thread applications[https://computing.llnl.gov/tutorials/pthreads/]. With UNIX starting to develop shared memory as a viable Inter-process communication tool developers started to create a high demand for the ability to run multiple threads under one process. Consequently, IEEE began to form together the POSIX standards. In 1988, POSIX.1 - created to support application portability – was ratified and accepted as the international standard in 1990[http://www.opengroup.org/austin/papers/posix_faq.html][http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=0607607821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091]. After the approval, the POSIX standard grew to more than 20 individual standards, encapsulating a large area of different groups[http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=0607607821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091].'''

'''POSIX.1 lays out the interfaces for OS services; their syntax, and how they should act. However, it does not define how the interface should be implemented on the OS, allowing many different operating systems to conform to standards in their own specific design and application[http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=0607607821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091]. POSIX.2 was created for much of the same reason as POSIX.1; portable shell programming and portable program development, but describes a programmable shell and its common utilities[https://computing.llnl.gov/tutorials/pthreads/]. Although POSIX.2 improved on the original, POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto Linux; this is due to the significant differences in relationship between POSIX and UNIX. These differences include: naming conventions (identifiers, operators, etc...), parameters and variables.[http://www.unix.org/whitepapers/shdiffs.html]'''

==Conclusion==

'''In the last twenty years, several advancements took place; there was a huge leap from the basic performance and function of a standard thread to a multi-threading, high performance POSIX thread. However, before it was given recognition as being efficient with high performance, a POSIX thread had numerous setbacks and high-priority challenges. Although the basic principle of a POSIX thread within UNIX was already executed by hardware sellers, it was under different names with minor structural variations, prohibiting developers to create portable thread applications. Fortunately, these issues were resolved and POSIX threads were enhanced, with continuous improvements on the way. Developers made an extraordinary breakthrough in concurrent programming by enabling efficiency and high performance, especially during immense modifications to data structure. Even with a rough past, POSIX threads have improved to become one of the most widely-known and commonly used method of adding concurrency to an application.'''

----

=Unsorted=
(unsorted essay)

-[[User:Npatel1|Npatel1]] ; here is the first paragraph. you can edit/add more to the paragraph if needed!

-Afranco2; I put in the history section/strung in tmalone's stuff as well. Again, feel free to edit/add content

-Tmalone; Edited and corrected the information thus far. I will post a conclusion sometime tomorrow.

-[[User:Npatel1|Npatel1]] ; Trevor, last lines should get us started on the conclusion. Afranco2; i went to class today and prof. was talking about plagiarism, can you please check your paragraph and see if there is any signs of plagiarism. since i don't know where you gathered your information from. upon you completion please post on wiki; need to make some modification to the body paragraph.

-http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=6626986821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091 That is one of the sources which I used for my information. I don't believe that I am plagiarizing, but I know that it is easy to do accidentally. If somebody wants to check it over for me to make sure, that would be great. My information comes from the first and second page. I also used POSIX Threads and the Linux Kernel and a little bit from IEEE POSIX Testing Policy General Information

-[[User:Npatel1|Npatel1]] ; oh i just wanted to make sure since the prof. emphasized on it a lot last class! thanks Afranco2.

POSIX (Portable Operating System Interface) threads, are high performance threads mainly distributed in UNIX but also to some Microsoft Windows OSes. Threads are used in parallel programming; when a system call executes, the thread runs on an independent stream to finish its task with minimal interruptions or slowdowns. Pthreads (from POSIX threads) are ideal for massive modifications to programs because the threads share one single memory space to alter a data structure, allowing constant high performance and efficiency. Pthreads have become a commonly used way of adding concurrency to an application. They are widely used in UNIX; a powerful operating system written in the C language, which is continuously enhanced. Developers came across various obstacles with POSIX threads; during the beginnings of Pthreads, many technical issues had surfaced which were resolved throughout the history of POSIX threads.

The history of POSIX Threads is that many hardware sellers executed their own versions of threads. These developments differed from one another, creating difficulties for programmers to implement portable thread applications. UNIX traditionally had a system running only a single thread under a process. These processes could not share memory and interacted using 'pipes'. Once developers started wanting to be able to run multiple threads under one process, IEEE began to form together the POSIX standards. In 1988 POSIX.1 (created to support application portability) was ratified and was accepted as the international standard in 1990. From there the POSIX standards grew to more than 20 individual standards, encapsulating a large area of different groups.

POSIX.1 lays out the interfaces for OS services; their syntax, and how they should act. It however does not define how the interface should be implemented on the OS. This is made to allow many different operating systems to conform to standards in their own specific design and application. POSIX.2 was created for much the same reason as POSIX.1 (portable shell programming, portable program development) but describes a programmable shell and its common utilities.

POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto Linux; this is due to the significant differences in relationship between POSIX and UNIX.

^^^ this statement sounds a bit off. why does UNIX care what Linux can handle? - John v.

I'll look into that tomorrow; working on 3005 Assignment. John, if you have a suggestion or an add-on that you wish to provide, please do so under collaboration.

-[[User:Npatel1|Npatel1]]

Hey guys, before end of tomorrow if there is anything missing or if anyone wishes to contribute more towards the essay please do so asap.

-[[User:Npatel1|Npatel1]]

UNIX cares about what Linux can handle because POSIX threads are mainly used in Linux systems. It is a very big deal if a certain type of thread is generating countless errors on the main system type the thread is created for. And regardless of just the fact that its widely used on Linux, UNIX would care because compatibility is one of the most important things to have. For a POSIX thread to not be compatible with Linux just because UNIX didn't care, then the progress of multi-threading and POSIX threads would not be able to be used in Linux. Then Linux would not be as widely used as it would not be enhanced like other systems. It is important for systems to have that compatibility, so that they don't end up left in the dust of technology.

-[[User:Tmalone|Tmalone]]

----

One of the major reasons why UNIX was so late to implement support for the POSIX threads is the way the two define "multi-threaded" process.
Traditionally UNIX defined a process to be an instance of a running program.With POSIX this came to be defined more precisely. The 'process'
was defined to be "an address-space and a group of resources dedicated to running the program". 
POSIX defines a 'thread' as the resources neccessary for a single thread of execution ie. a single execution path. Thus according to POSIX the basic unit of execution is a thread. On the other hand UNIX traditionally defined a 'task' as the basic unit of execution which is essentially same as the POSIX definition of a 'process'. 
Now the conflict between the POSIX Threads and UNIX implementation of tasks came when a task used a clone() system call to create another task in order to implement multi-threading. The program then becomes a co-operating set of tasks which share 'some' resources. It is due to this halfway implementation of sharing of resources that lies the major conflict. In a nutshell the fundamental difference between the two is that in POSIX a process can be addressed as a single entity, while in Linux it is a collection of independent tasks. In the POSIX thread implementation all actions affect the entire process. In Linux, however, each of these actions will only affect one task.

Not from your group. But I think your essay should incorporate this too. --[[User:Gautam|Gautam]] 19:35, 14 October 2010 (UTC)

Appreciate your contribution towards the essay even though your not in our group; if its possible, can you please give us the link to which you got the information from. --[[User:Npatel1|Npatel1]]

=Collaboration=

Hey guys, i'm just gunna get this started by posting a few links for everyone to get going. This will help explain a general idea of what they are and the history of them. Please add some more links or anything else you think would be helpful!

http://en.wikipedia.org/wiki/POSIX_Threads
https://computing.llnl.gov/tutorials/pthreads/
http://sourceware.org/pthreads-win32/

-[[User:tmalone|tmalone]]

I found this, might not help, but it might:--[[User:Rannath|Rannath]] 02:09, 6 October 2010 (UTC)

I'm not sure about the rest of you, but most of what I am able to find has to do with information on things that fall under POSIX, not actually about POSIX-afranco2

POSIX Threads, or pthreads, is a thread that is commonly used in UNIX systems but it also seen in some Microsoft Windows systems. A thread is a unit of process that executes segments of code within applications. When a process gets called from the system, the thread will execute the code for the process. POSIX stands for Portable Operating System Interface (for UNIX) and has been used by many independent sellers of hardware. There has always been issues such that developers could not create a reliable protable pthread application. For the use of multi-threading, its implementation arrived fairly late because the systems could not support it. Data mapping onto Linux gave birth to several problems due to the fact that POSIX and UNIX were implemented so differently.

-[[User:tmalone|tmalone]]

http://www.faqs.org/faqs/os-research/part1/section-10.html

Might be of some use as well --[[User:Lmundt|Lmundt]] 14:48, 7 October 2010 (UTC)
https://computing.llnl.gov/tutorials/pthreads/

Edited version from what -tmalone has written.

POSIX Threads is also called pthreads. Portable Operating System interface; mainly for Unix but it’s also distributed to some Microsoft Windows OS. A Thread is a unit of process that resides inside a process and executes when a system call has been executed. Threads have same global and all the threads share memory, threads also contain their personal private data. Pthread has become commonly used a way of adding concurrency to an application. The history of POSIX Threads is that many hardware sellers executed their own versions of threads. These developments differed from one another, creating difficulties for programmers to implement portable thread applications. POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto linux; this is due to the significant differences in relationship between POSIX and UNIX.

-Npatel1

A bit different of a explanation of the history of threads in Unix:

Originally in UNIX things similar to threads existed, they were however, called processes. The “processes” shared memory and used semaphores and thus “threads” have been around from the start. However, they disappeared when UNIX took the multics definition of process to mean they should not share memory, and all of sudden the ability to have threads disappeared. As people clamored to have the good old processes back, they created a new thing called “threads” that was actually what they had previously. So while it seemed they were late to support multithreaded processes, in reality they merely had a brief period where they didn’t have multi-threadedness.

-[[User:Rift|Rift]] 23:42, 10 October 2010 (UTC)

Here is a possible simple conclusion I've typed up. I used the first chunk of Rifts paragraph then just threw in some extra info. Go easy on me lol

Originally in UNIX things similar to threads existed, they were however, called processes. The “processes” shared memory and used semaphores and thus “threads” have been around from the start. However, they disappeared when UNIX took the multics definition of process to mean they should not share memory, and all of sudden the ability to have threads disappeared. What are now considered POSIX threads have just been aliased for many years. The late implementation of these threads was because of the fact that so many developers had the basic principle of a POSIX thread in use, it was simply under a different name with minor structural differences. It is quite evident how POSIX threads came to be over the years especially within the UNIX system. From the basic performance and function of a standard thread to the multi-threading abilities of the POSIX thread, the development became more and more concrete. Though problems arose, such as creating portable thread applications between developers, solutions were found. POSIX.1 and POSIX.2 were created to display interfaces with specific syntax and to describe programming shells for many operating systems. Given the last 20 years when the leap was taken between a standard thread and a POSIX thread, and the speed in which the POSIX thread has been implemented, it can be said that given another 20 years the POSIX thread will have turned into something even more worth the wait.

Okay guys this is a conclusion I've typed up. I have absolutely no idea if this is good enough, I find it pretty tough to write conclusions. Nonetheless, feel free to make changes and add/delete whatever you want. I'm not sure how formal he wants it to be, but I hope this is at least decent. If you want me to make some changes let me know what to change and I'll do it asap.

(I constantly make changes myself :p)

- Tmalone

==References==

[1] The Open Group, 1997 - 1999. What is UNIX? online at: <http://www.unix.org/whitepapers/shdiffs.html>

[2] Ross Johnson. POSIX Threads for Win32. online at: <http://sourceware.org/pthreads-win32/>

[3] Blaise Barney, 2010. Lawrence Livermore National Laboratory. POSIX Threads Programming. online at: <https://computing.llnl.gov/tutorials/pthreads/>

[4] Dave McCracken, 2002. IBM Linux Technology Center. POSIX Threads and the Linux Kernel. online at: <//www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf>

[5] L. Blunt Jackson, 2005. NPTL: The New Implementation of Threads for Linux. online at: <http://www.drdobbs.com/open-source/184406204>

[6] Institute of Electrical and Electronics Engineers, Inc, 1998. IEEE POSIX Testing Policy - General Information. online at: <http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf>

[7] A Short History of UNIX, 2006. online at: <http://www.unix.com/unix-dummies-questions-answers/7-short-history-unix-l-madden-ic-ac-uk.html>

[8] Bradford Nichols, Dick Buttlar, and Jacqueline Proulx Farrell, O'Reilly & Associates, Inc, 1996. Pthreads Programming. online at: <http://books.google.ca/books?id=EZfElJsWCqgC&pg=PA198&lpg=PA198&dq=kernel+based+pthreads&source=bl&ots=3HFKw_0nqq&sig=P0L9feIb88xJRzQfLd7maKtVnTU&hl=en&ei=Oky3TM-_OaO0nAf1-YiwCA&sa=X&oi=book_result&ct=result&resnum=6&ved=0CCsQ6AEwBQ#v=onepage&q=kernel%20based%20pthreads&f=false>

[9] Bryan O'Sullivan, 1993 - 1996. The History of Threads. online at: <http://www.faqs.org/faqs/os-research/part1/section-10.html>

[10] Lucent Technologies, 2002. The Famous PDP-7 Comes to the Rescue (And Continuous Pages). online at: <http://www.bell-labs.com/history/unix/pdp7.html>

[12] Robert Love, 2003. Introducing the 2.6 Kernel. online at: <http://www.linuxjournal.com/article/6530>

[13] Janice J. Heiss, 2003. Oracle. Red Hat Linux 9 and Java 2 Platform, Standard Edition 1.4.2: A Winning Combination. online at: <http://java.sun.com/developer/technicalArticles/JavaTechandLinux/RedHat/>

[14] Dennis M. Ritchie, 1996. Bell Laboratoeries, The Evolution of the UNIX Time-Sharing System. online at: <http://cm.bell-labs.com/cm/cs/who/dmr/hist.html>

[15] The Linux Information Project, 2004. Pipes: A Brief Introduction. online at: <http://www.linfo.org/pipe.html>

COMP 3000 Essay 1 2010 Question 8

2010-10-14T23:41:05Z

Tmalone: /* References */

=Question=

What is the history of POSIX Threads (pthreads)? Consider - does this history explain why UNIX was so late to implement support for multithreaded processes?

=Essay=

-[[User:Npatel1|Npatel1]] ; here is the final copy guys, feel free to edit the essay under "Unsorted". if it requires major changes please post a note in discussion board, cheers.

-Started throwing in some citation links. Some are duplicates because I'm not sure how to really do them correctly (kind of a wiki noob) -Afranco2
----

'''POSIX threads, also known as Portable Operating System Interface, are high performance threads mainly distributed in UNIX but also to some Microsoft Windows OS. Threads are used in parallel programming; when a system call executes, the thread runs on an independent stream to finish its task with minimal interruptions or slowdowns. Pthreads are ideal for massive modifications to programs because the threads share one single memory space to alter a data structure, allowing constant high performance and efficiency. Pthread has become commonly used a way of adding concurrency to an application. They are widely used in UNIX; a powerful operating system written in the C language, which is continuously enhanced. Developers came across various obstacles with POSIX threads; during the beginnings of Pthreads, many technical issues had surfaced which were resolved throughout the history of POSIX threads.'''

'''The notion of threads developed naturally out of the desire for processes to communicate with each other. Threads are at a basic level multiple threads of control that share memory, and sharing memory is a relatively instantaneous method of communication. In UNIX where processes were seen as needed on a 1:1 per-terminal basis, and more about time-sharing then working together, at first this seemed relatively unnecessary[http://tinf2.vub.ac.be/~dvermeir/manuals/KDE20Development-html/ch13lev1sec2.html]. Retrieved on October 14 2010</ref>. There were after all, mechanisms in place to communicate between processes such as pipes and temporary files as well as a few "just changed" messages. The first UNIX implementation of shared memory came about in 1983 with the System V UNIX flavor, which shared memory was merely one of several upgrades to passing messages between processes.[http://fscked.org/writings/SHM/shm-5.html]'''

'''The beginning of POSIX Threads starts off with hardware sellers executing their own versions of threads[https://computing.llnl.gov/tutorials/pthreads/]. These developments varied from one another, creating difficulties for programmers to implement portable thread applications[https://computing.llnl.gov/tutorials/pthreads/]. With UNIX starting to develop shared memory as a viable Inter-process communication tool developers started to create a high demand for the ability to run multiple threads under one process. Consequently, IEEE began to form together the POSIX standards. In 1988, POSIX.1 - created to support application portability – was ratified and accepted as the international standard in 1990[http://www.opengroup.org/austin/papers/posix_faq.html][http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=0607607821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091]. After the approval, the POSIX standard grew to more than 20 individual standards, encapsulating a large area of different groups[http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=0607607821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091].'''

'''POSIX.1 lays out the interfaces for OS services; their syntax, and how they should act. However, it does not define how the interface should be implemented on the OS, allowing many different operating systems to conform to standards in their own specific design and application[http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=0607607821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091]. POSIX.2 was created for much of the same reason as POSIX.1; portable shell programming and portable program development, but describes a programmable shell and its common utilities[https://computing.llnl.gov/tutorials/pthreads/]. Although POSIX.2 improved on the original, POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto Linux; this is due to the significant differences in relationship between POSIX and UNIX. These differences include: naming conventions (identifiers, operators, etc...), parameters and variables.[http://www.unix.org/whitepapers/shdiffs.html]'''

'''In the last twenty years, several advancements took place; there was a huge leap from the basic performance and function of a standard thread to a multi-threading, high performance POSIX thread. However, before it was given recognition as being efficient with high performance, a POSIX thread had numerous setbacks and high-priority challenges. Although the basic principle of a POSIX thread within UNIX was already executed by hardware sellers, it was under different names with minor structural variations, prohibiting developers to create portable thread applications. Fortunately, these issues were resolved and POSIX threads were enhanced, with continuous improvements on the way. Developers made an extraordinary breakthrough in concurrent programming by enabling efficiency and high performance, especially during immense modifications to data structure. Even with a rough past, POSIX threads have improved to become one of the most widely-known and commonly used method of adding concurrency to an application.'''

----

=Unsorted=
(unsorted essay)

-[[User:Npatel1|Npatel1]] ; here is the first paragraph. you can edit/add more to the paragraph if needed!

-Afranco2; I put in the history section/strung in tmalone's stuff as well. Again, feel free to edit/add content

-Tmalone; Edited and corrected the information thus far. I will post a conclusion sometime tomorrow.

-[[User:Npatel1|Npatel1]] ; Trevor, last lines should get us started on the conclusion. Afranco2; i went to class today and prof. was talking about plagiarism, can you please check your paragraph and see if there is any signs of plagiarism. since i don't know where you gathered your information from. upon you completion please post on wiki; need to make some modification to the body paragraph.

-http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=6626986821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091 That is one of the sources which I used for my information. I don't believe that I am plagiarizing, but I know that it is easy to do accidentally. If somebody wants to check it over for me to make sure, that would be great. My information comes from the first and second page. I also used POSIX Threads and the Linux Kernel and a little bit from IEEE POSIX Testing Policy General Information

-[[User:Npatel1|Npatel1]] ; oh i just wanted to make sure since the prof. emphasized on it a lot last class! thanks Afranco2.

POSIX (Portable Operating System Interface) threads, are high performance threads mainly distributed in UNIX but also to some Microsoft Windows OSes. Threads are used in parallel programming; when a system call executes, the thread runs on an independent stream to finish its task with minimal interruptions or slowdowns. Pthreads (from POSIX threads) are ideal for massive modifications to programs because the threads share one single memory space to alter a data structure, allowing constant high performance and efficiency. Pthreads have become a commonly used way of adding concurrency to an application. They are widely used in UNIX; a powerful operating system written in the C language, which is continuously enhanced. Developers came across various obstacles with POSIX threads; during the beginnings of Pthreads, many technical issues had surfaced which were resolved throughout the history of POSIX threads.

The history of POSIX Threads is that many hardware sellers executed their own versions of threads. These developments differed from one another, creating difficulties for programmers to implement portable thread applications. UNIX traditionally had a system running only a single thread under a process. These processes could not share memory and interacted using 'pipes'. Once developers started wanting to be able to run multiple threads under one process, IEEE began to form together the POSIX standards. In 1988 POSIX.1 (created to support application portability) was ratified and was accepted as the international standard in 1990. From there the POSIX standards grew to more than 20 individual standards, encapsulating a large area of different groups.

POSIX.1 lays out the interfaces for OS services; their syntax, and how they should act. It however does not define how the interface should be implemented on the OS. This is made to allow many different operating systems to conform to standards in their own specific design and application. POSIX.2 was created for much the same reason as POSIX.1 (portable shell programming, portable program development) but describes a programmable shell and its common utilities.

POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto Linux; this is due to the significant differences in relationship between POSIX and UNIX.

^^^ this statement sounds a bit off. why does UNIX care what Linux can handle? - John v.

I'll look into that tomorrow; working on 3005 Assignment. John, if you have a suggestion or an add-on that you wish to provide, please do so under collaboration.

-[[User:Npatel1|Npatel1]]

Hey guys, before end of tomorrow if there is anything missing or if anyone wishes to contribute more towards the essay please do so asap.

-[[User:Npatel1|Npatel1]]

UNIX cares about what Linux can handle because POSIX threads are mainly used in Linux systems. It is a very big deal if a certain type of thread is generating countless errors on the main system type the thread is created for. And regardless of just the fact that its widely used on Linux, UNIX would care because compatibility is one of the most important things to have. For a POSIX thread to not be compatible with Linux just because UNIX didn't care, then the progress of multi-threading and POSIX threads would not be able to be used in Linux. Then Linux would not be as widely used as it would not be enhanced like other systems. It is important for systems to have that compatibility, so that they don't end up left in the dust of technology.

-[[User:Tmalone|Tmalone]]

----

One of the major reasons why UNIX was so late to implement support for the POSIX threads is the way the two define "multi-threaded" process.
Traditionally UNIX defined a process to be an instance of a running program.With POSIX this came to be defined more precisely. The 'process'
was defined to be "an address-space and a group of resources dedicated to running the program". 
POSIX defines a 'thread' as the resources neccessary for a single thread of execution ie. a single execution path. Thus according to POSIX the basic unit of execution is a thread. On the other hand UNIX traditionally defined a 'task' as the basic unit of execution which is essentially same as the POSIX definition of a 'process'. 
Now the conflict between the POSIX Threads and UNIX implementation of tasks came when a task used a clone() system call to create another task in order to implement multi-threading. The program then becomes a co-operating set of tasks which share 'some' resources. It is due to this halfway implementation of sharing of resources that lies the major conflict. In a nutshell the fundamental difference between the two is that in POSIX a process can be addressed as a single entity, while in Linux it is a collection of independent tasks. In the POSIX thread implementation all actions affect the entire process. In Linux, however, each of these actions will only affect one task.

Not from your group. But I think your essay should incorporate this too. --[[User:Gautam|Gautam]] 19:35, 14 October 2010 (UTC)

Appreciate your contribution towards the essay even though your not in our group; if its possible, can you please give us the link to which you got the information from. --[[User:Npatel1|Npatel1]]

=Collaboration=

Hey guys, i'm just gunna get this started by posting a few links for everyone to get going. This will help explain a general idea of what they are and the history of them. Please add some more links or anything else you think would be helpful!

http://en.wikipedia.org/wiki/POSIX_Threads
https://computing.llnl.gov/tutorials/pthreads/
http://sourceware.org/pthreads-win32/

-[[User:tmalone|tmalone]]

I found this, might not help, but it might:--[[User:Rannath|Rannath]] 02:09, 6 October 2010 (UTC)

I'm not sure about the rest of you, but most of what I am able to find has to do with information on things that fall under POSIX, not actually about POSIX-afranco2

POSIX Threads, or pthreads, is a thread that is commonly used in UNIX systems but it also seen in some Microsoft Windows systems. A thread is a unit of process that executes segments of code within applications. When a process gets called from the system, the thread will execute the code for the process. POSIX stands for Portable Operating System Interface (for UNIX) and has been used by many independent sellers of hardware. There has always been issues such that developers could not create a reliable protable pthread application. For the use of multi-threading, its implementation arrived fairly late because the systems could not support it. Data mapping onto Linux gave birth to several problems due to the fact that POSIX and UNIX were implemented so differently.

-[[User:tmalone|tmalone]]

http://www.faqs.org/faqs/os-research/part1/section-10.html

Might be of some use as well --[[User:Lmundt|Lmundt]] 14:48, 7 October 2010 (UTC)
https://computing.llnl.gov/tutorials/pthreads/

Edited version from what -tmalone has written.

POSIX Threads is also called pthreads. Portable Operating System interface; mainly for Unix but it’s also distributed to some Microsoft Windows OS. A Thread is a unit of process that resides inside a process and executes when a system call has been executed. Threads have same global and all the threads share memory, threads also contain their personal private data. Pthread has become commonly used a way of adding concurrency to an application. The history of POSIX Threads is that many hardware sellers executed their own versions of threads. These developments differed from one another, creating difficulties for programmers to implement portable thread applications. POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto linux; this is due to the significant differences in relationship between POSIX and UNIX.

-Npatel1

A bit different of a explanation of the history of threads in Unix:

Originally in UNIX things similar to threads existed, they were however, called processes. The “processes” shared memory and used semaphores and thus “threads” have been around from the start. However, they disappeared when UNIX took the multics definition of process to mean they should not share memory, and all of sudden the ability to have threads disappeared. As people clamored to have the good old processes back, they created a new thing called “threads” that was actually what they had previously. So while it seemed they were late to support multithreaded processes, in reality they merely had a brief period where they didn’t have multi-threadedness.

-[[User:Rift|Rift]] 23:42, 10 October 2010 (UTC)

Here is a possible simple conclusion I've typed up. I used the first chunk of Rifts paragraph then just threw in some extra info. Go easy on me lol

Originally in UNIX things similar to threads existed, they were however, called processes. The “processes” shared memory and used semaphores and thus “threads” have been around from the start. However, they disappeared when UNIX took the multics definition of process to mean they should not share memory, and all of sudden the ability to have threads disappeared. What are now considered POSIX threads have just been aliased for many years. The late implementation of these threads was because of the fact that so many developers had the basic principle of a POSIX thread in use, it was simply under a different name with minor structural differences. It is quite evident how POSIX threads came to be over the years especially within the UNIX system. From the basic performance and function of a standard thread to the multi-threading abilities of the POSIX thread, the development became more and more concrete. Though problems arose, such as creating portable thread applications between developers, solutions were found. POSIX.1 and POSIX.2 were created to display interfaces with specific syntax and to describe programming shells for many operating systems. Given the last 20 years when the leap was taken between a standard thread and a POSIX thread, and the speed in which the POSIX thread has been implemented, it can be said that given another 20 years the POSIX thread will have turned into something even more worth the wait.

Okay guys this is a conclusion I've typed up. I have absolutely no idea if this is good enough, I find it pretty tough to write conclusions. Nonetheless, feel free to make changes and add/delete whatever you want. I'm not sure how formal he wants it to be, but I hope this is at least decent. If you want me to make some changes let me know what to change and I'll do it asap.

(I constantly make changes myself :p)

- Tmalone

==References==

[1] The Open Group, 1997 - 1999. What is UNIX? online at: <http://www.unix.org/whitepapers/shdiffs.html>

[2] Ross Johnson. POSIX Threads for Win32. online at: <http://sourceware.org/pthreads-win32/>

[3] Blaise Barney, 2010. Lawrence Livermore National Laboratory. POSIX Threads Programming. online at: <https://computing.llnl.gov/tutorials/pthreads/>

[4] Dave McCracken, 2002. IBM Linux Technology Center. POSIX Threads and the Linux Kernel. online at: <//www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf>

[5] L. Blunt Jackson, 2005. NPTL: The New Implementation of Threads for Linux. online at: <http://www.drdobbs.com/open-source/184406204>

[6] Institute of Electrical and Electronics Engineers, Inc, 1998. IEEE POSIX Testing Policy - General Information. online at: <http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf>

[7] A Short History of UNIX, 2006. online at: <http://www.unix.com/unix-dummies-questions-answers/7-short-history-unix-l-madden-ic-ac-uk.html>

[8] Bradford Nichols, Dick Buttlar, and Jacqueline Proulx Farrell, O'Reilly & Associates, Inc, 1996. Pthreads Programming. online at: <http://books.google.ca/books?id=EZfElJsWCqgC&pg=PA198&lpg=PA198&dq=kernel+based+pthreads&source=bl&ots=3HFKw_0nqq&sig=P0L9feIb88xJRzQfLd7maKtVnTU&hl=en&ei=Oky3TM-_OaO0nAf1-YiwCA&sa=X&oi=book_result&ct=result&resnum=6&ved=0CCsQ6AEwBQ#v=onepage&q=kernel%20based%20pthreads&f=false>

[9] Bryan O'Sullivan, 1993 - 1996. The History of Threads. online at: <http://www.faqs.org/faqs/os-research/part1/section-10.html>

[10] http://en.wikipedia.org/wiki/Pipeline_%28Unix%29

[11] http://en.wikipedia.org/wiki/Unix#1970s

[12] http://en.wikipedia.org/wiki/Native_POSIX_Thread_Library

COMP 3000 Essay 1 2010 Question 8

2010-10-14T23:25:09Z

Tmalone: /* References */

=Question=

What is the history of POSIX Threads (pthreads)? Consider - does this history explain why UNIX was so late to implement support for multithreaded processes?

=Essay=

-[[User:Npatel1|Npatel1]] ; here is the final copy guys, feel free to edit the essay under "Unsorted". if it requires major changes please post a note in discussion board, cheers.

-Started throwing in some citation links. Some are duplicates because I'm not sure how to really do them correctly (kind of a wiki noob) -Afranco2
----

'''POSIX threads, also known as Portable Operating System Interface, are high performance threads mainly distributed in UNIX but also to some Microsoft Windows OS. Threads are used in parallel programming; when a system call executes, the thread runs on an independent stream to finish its task with minimal interruptions or slowdowns. Pthreads are ideal for massive modifications to programs because the threads share one single memory space to alter a data structure, allowing constant high performance and efficiency. Pthread has become commonly used a way of adding concurrency to an application. They are widely used in UNIX; a powerful operating system written in the C language, which is continuously enhanced. Developers came across various obstacles with POSIX threads; during the beginnings of Pthreads, many technical issues had surfaced which were resolved throughout the history of POSIX threads.'''

'''The notion of threads developed naturally out of the desire for processes to communicate with each other. Threads are at a basic level multiple threads of control that share memory, and sharing memory is a relatively instantaneous method of communication. In UNIX where processes were seen as needed on a 1:1 per-terminal basis, and more about time-sharing then working together, at first this seemed relatively unnecessary[http://tinf2.vub.ac.be/~dvermeir/manuals/KDE20Development-html/ch13lev1sec2.html]. Retrieved on October 14 2010</ref>. There were after all, mechanisms in place to communicate between processes such as pipes and temporary files as well as a few "just changed" messages. The first UNIX implementation of shared memory came about in 1983 with the System V UNIX flavor, which shared memory was merely one of several upgrades to passing messages between processes.[http://fscked.org/writings/SHM/shm-5.html]'''

'''The beginning of POSIX Threads starts off with hardware sellers executing their own versions of threads[https://computing.llnl.gov/tutorials/pthreads/]. These developments varied from one another, creating difficulties for programmers to implement portable thread applications[https://computing.llnl.gov/tutorials/pthreads/]. With UNIX starting to develop shared memory as a viable Inter-process communication tool developers started to create a high demand for the ability to run multiple threads under one process. Consequently, IEEE began to form together the POSIX standards. In 1988, POSIX.1 - created to support application portability – was ratified and accepted as the international standard in 1990[http://www.opengroup.org/austin/papers/posix_faq.html][http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=0607607821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091]. After the approval, the POSIX standard grew to more than 20 individual standards, encapsulating a large area of different groups[http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=0607607821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091].'''

'''POSIX.1 lays out the interfaces for OS services; their syntax, and how they should act. However, it does not define how the interface should be implemented on the OS, allowing many different operating systems to conform to standards in their own specific design and application[http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=0607607821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091]. POSIX.2 was created for much of the same reason as POSIX.1; portable shell programming and portable program development, but describes a programmable shell and its common utilities[https://computing.llnl.gov/tutorials/pthreads/]. Although POSIX.2 improved on the original, POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto Linux; this is due to the significant differences in relationship between POSIX and UNIX. These differences include: naming conventions (identifiers, operators, etc...), parameters and variables.[http://www.unix.org/whitepapers/shdiffs.html]'''

'''In the last twenty years, several advancements took place; there was a huge leap from the basic performance and function of a standard thread to a multi-threading, high performance POSIX thread. However, before it was given recognition as being efficient with high performance, a POSIX thread had numerous setbacks and high-priority challenges. Although the basic principle of a POSIX thread within UNIX was already executed by hardware sellers, it was under different names with minor structural variations, prohibiting developers to create portable thread applications. Fortunately, these issues were resolved and POSIX threads were enhanced, with continuous improvements on the way. Developers made an extraordinary breakthrough in concurrent programming by enabling efficiency and high performance, especially during immense modifications to data structure. Even with a rough past, POSIX threads have improved to become one of the most widely-known and commonly used method of adding concurrency to an application.'''

----

=Unsorted=
(unsorted essay)

-[[User:Npatel1|Npatel1]] ; here is the first paragraph. you can edit/add more to the paragraph if needed!

-Afranco2; I put in the history section/strung in tmalone's stuff as well. Again, feel free to edit/add content

-Tmalone; Edited and corrected the information thus far. I will post a conclusion sometime tomorrow.

-[[User:Npatel1|Npatel1]] ; Trevor, last lines should get us started on the conclusion. Afranco2; i went to class today and prof. was talking about plagiarism, can you please check your paragraph and see if there is any signs of plagiarism. since i don't know where you gathered your information from. upon you completion please post on wiki; need to make some modification to the body paragraph.

-http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=6626986821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091 That is one of the sources which I used for my information. I don't believe that I am plagiarizing, but I know that it is easy to do accidentally. If somebody wants to check it over for me to make sure, that would be great. My information comes from the first and second page. I also used POSIX Threads and the Linux Kernel and a little bit from IEEE POSIX Testing Policy General Information

-[[User:Npatel1|Npatel1]] ; oh i just wanted to make sure since the prof. emphasized on it a lot last class! thanks Afranco2.

POSIX (Portable Operating System Interface) threads, are high performance threads mainly distributed in UNIX but also to some Microsoft Windows OSes. Threads are used in parallel programming; when a system call executes, the thread runs on an independent stream to finish its task with minimal interruptions or slowdowns. Pthreads (from POSIX threads) are ideal for massive modifications to programs because the threads share one single memory space to alter a data structure, allowing constant high performance and efficiency. Pthreads have become a commonly used way of adding concurrency to an application. They are widely used in UNIX; a powerful operating system written in the C language, which is continuously enhanced. Developers came across various obstacles with POSIX threads; during the beginnings of Pthreads, many technical issues had surfaced which were resolved throughout the history of POSIX threads.

The history of POSIX Threads is that many hardware sellers executed their own versions of threads. These developments differed from one another, creating difficulties for programmers to implement portable thread applications. UNIX traditionally had a system running only a single thread under a process. These processes could not share memory and interacted using 'pipes'. Once developers started wanting to be able to run multiple threads under one process, IEEE began to form together the POSIX standards. In 1988 POSIX.1 (created to support application portability) was ratified and was accepted as the international standard in 1990. From there the POSIX standards grew to more than 20 individual standards, encapsulating a large area of different groups.

POSIX.1 lays out the interfaces for OS services; their syntax, and how they should act. It however does not define how the interface should be implemented on the OS. This is made to allow many different operating systems to conform to standards in their own specific design and application. POSIX.2 was created for much the same reason as POSIX.1 (portable shell programming, portable program development) but describes a programmable shell and its common utilities.

POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto Linux; this is due to the significant differences in relationship between POSIX and UNIX.

^^^ this statement sounds a bit off. why does UNIX care what Linux can handle? - John v.

I'll look into that tomorrow; working on 3005 Assignment. John, if you have a suggestion or an add-on that you wish to provide, please do so under collaboration.

-[[User:Npatel1|Npatel1]]

Hey guys, before end of tomorrow if there is anything missing or if anyone wishes to contribute more towards the essay please do so asap.

-[[User:Npatel1|Npatel1]]

UNIX cares about what Linux can handle because POSIX threads are mainly used in Linux systems. It is a very big deal if a certain type of thread is generating countless errors on the main system type the thread is created for. And regardless of just the fact that its widely used on Linux, UNIX would care because compatibility is one of the most important things to have. For a POSIX thread to not be compatible with Linux just because UNIX didn't care, then the progress of multi-threading and POSIX threads would not be able to be used in Linux. Then Linux would not be as widely used as it would not be enhanced like other systems. It is important for systems to have that compatibility, so that they don't end up left in the dust of technology.

-[[User:Tmalone|Tmalone]]

----

One of the major reasons why UNIX was so late to implement support for the POSIX threads is the way the two define "multi-threaded" process.
Traditionally UNIX defined a process to be an instance of a running program.With POSIX this came to be defined more precisely. The 'process'
was defined to be "an address-space and a group of resources dedicated to running the program". 
POSIX defines a 'thread' as the resources neccessary for a single thread of execution ie. a single execution path. Thus according to POSIX the basic unit of execution is a thread. On the other hand UNIX traditionally defined a 'task' as the basic unit of execution which is essentially same as the POSIX definition of a 'process'. 
Now the conflict between the POSIX Threads and UNIX implementation of tasks came when a task used a clone() system call to create another task in order to implement multi-threading. The program then becomes a co-operating set of tasks which share 'some' resources. It is due to this halfway implementation of sharing of resources that lies the major conflict. In a nutshell the fundamental difference between the two is that in POSIX a process can be addressed as a single entity, while in Linux it is a collection of independent tasks. In the POSIX thread implementation all actions affect the entire process. In Linux, however, each of these actions will only affect one task.

Not from your group. But I think your essay should incorporate this too. --[[User:Gautam|Gautam]] 19:35, 14 October 2010 (UTC)

Appreciate your contribution towards the essay even though your not in our group; if its possible, can you please give us the link to which you got the information from. --[[User:Npatel1|Npatel1]]

=Collaboration=

Hey guys, i'm just gunna get this started by posting a few links for everyone to get going. This will help explain a general idea of what they are and the history of them. Please add some more links or anything else you think would be helpful!

http://en.wikipedia.org/wiki/POSIX_Threads
https://computing.llnl.gov/tutorials/pthreads/
http://sourceware.org/pthreads-win32/

-[[User:tmalone|tmalone]]

I found this, might not help, but it might:--[[User:Rannath|Rannath]] 02:09, 6 October 2010 (UTC)

I'm not sure about the rest of you, but most of what I am able to find has to do with information on things that fall under POSIX, not actually about POSIX-afranco2

POSIX Threads, or pthreads, is a thread that is commonly used in UNIX systems but it also seen in some Microsoft Windows systems. A thread is a unit of process that executes segments of code within applications. When a process gets called from the system, the thread will execute the code for the process. POSIX stands for Portable Operating System Interface (for UNIX) and has been used by many independent sellers of hardware. There has always been issues such that developers could not create a reliable protable pthread application. For the use of multi-threading, its implementation arrived fairly late because the systems could not support it. Data mapping onto Linux gave birth to several problems due to the fact that POSIX and UNIX were implemented so differently.

-[[User:tmalone|tmalone]]

http://www.faqs.org/faqs/os-research/part1/section-10.html

Might be of some use as well --[[User:Lmundt|Lmundt]] 14:48, 7 October 2010 (UTC)
https://computing.llnl.gov/tutorials/pthreads/

Edited version from what -tmalone has written.

POSIX Threads is also called pthreads. Portable Operating System interface; mainly for Unix but it’s also distributed to some Microsoft Windows OS. A Thread is a unit of process that resides inside a process and executes when a system call has been executed. Threads have same global and all the threads share memory, threads also contain their personal private data. Pthread has become commonly used a way of adding concurrency to an application. The history of POSIX Threads is that many hardware sellers executed their own versions of threads. These developments differed from one another, creating difficulties for programmers to implement portable thread applications. POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto linux; this is due to the significant differences in relationship between POSIX and UNIX.

-Npatel1

A bit different of a explanation of the history of threads in Unix:

Originally in UNIX things similar to threads existed, they were however, called processes. The “processes” shared memory and used semaphores and thus “threads” have been around from the start. However, they disappeared when UNIX took the multics definition of process to mean they should not share memory, and all of sudden the ability to have threads disappeared. As people clamored to have the good old processes back, they created a new thing called “threads” that was actually what they had previously. So while it seemed they were late to support multithreaded processes, in reality they merely had a brief period where they didn’t have multi-threadedness.

-[[User:Rift|Rift]] 23:42, 10 October 2010 (UTC)

Here is a possible simple conclusion I've typed up. I used the first chunk of Rifts paragraph then just threw in some extra info. Go easy on me lol

Originally in UNIX things similar to threads existed, they were however, called processes. The “processes” shared memory and used semaphores and thus “threads” have been around from the start. However, they disappeared when UNIX took the multics definition of process to mean they should not share memory, and all of sudden the ability to have threads disappeared. What are now considered POSIX threads have just been aliased for many years. The late implementation of these threads was because of the fact that so many developers had the basic principle of a POSIX thread in use, it was simply under a different name with minor structural differences. It is quite evident how POSIX threads came to be over the years especially within the UNIX system. From the basic performance and function of a standard thread to the multi-threading abilities of the POSIX thread, the development became more and more concrete. Though problems arose, such as creating portable thread applications between developers, solutions were found. POSIX.1 and POSIX.2 were created to display interfaces with specific syntax and to describe programming shells for many operating systems. Given the last 20 years when the leap was taken between a standard thread and a POSIX thread, and the speed in which the POSIX thread has been implemented, it can be said that given another 20 years the POSIX thread will have turned into something even more worth the wait.

Okay guys this is a conclusion I've typed up. I have absolutely no idea if this is good enough, I find it pretty tough to write conclusions. Nonetheless, feel free to make changes and add/delete whatever you want. I'm not sure how formal he wants it to be, but I hope this is at least decent. If you want me to make some changes let me know what to change and I'll do it asap.

(I constantly make changes myself :p)

- Tmalone

==References==

[1] The Open Group, 1997 - 1999. What is UNIX? online at: <http://www.unix.org/whitepapers/shdiffs.html>

[2] Ross Johnson. POSIX Threads for Win32. online at: <http://sourceware.org/pthreads-win32/>

[3] Blaise Barney. Lawrence Livermore National Laboratory. online at: <https://computing.llnl.gov/tutorials/pthreads/>

[4] http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf

[5] http://www.drdobbs.com/open-source/184406204;jsessionid=GKSVKT3EOMUBDQE1GHRSKHWATMY32JVN

[6] http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf

[7] http://www.unix.com/unix-dummies-questions-answers/7-short-history-unix-l-madden-ic-ac-uk.html

[9] http://en.wikipedia.org/wiki/Pipeline_%28Unix%29

[10] http://en.wikipedia.org/wiki/Unix#1970s

[11] http://books.google.ca/books?id=EZfElJsWCqgC&pg=PA198&lpg=PA198&dq=kernel+based+pthreads&source=bl&ots=3HFKw_0nqq&sig=P0L9feIb88xJRzQfLd7maKtVnTU&hl=en&ei=Oky3TM-_OaO0nAf1-YiwCA&sa=X&oi=book_result&ct=result&resnum=6&ved=0CCsQ6AEwBQ#v=onepage&q=kernel%20based%20pthreads&f=false

[12] http://en.wikipedia.org/wiki/Native_POSIX_Thread_Library

[13] http://www.faqs.org/faqs/os-research/part1/section-10.html

COMP 3000 Essay 1 2010 Question 8

2010-10-14T23:08:44Z

Tmalone: /* References */

=Question=

What is the history of POSIX Threads (pthreads)? Consider - does this history explain why UNIX was so late to implement support for multithreaded processes?

=Essay=

-[[User:Npatel1|Npatel1]] ; here is the final copy guys, feel free to edit the essay under "Unsorted". if it requires major changes please post a note in discussion board, cheers.

-Started throwing in some citation links. Some are duplicates because I'm not sure how to really do them correctly (kind of a wiki noob) -Afranco2
----

'''POSIX threads, also known as Portable Operating System Interface, are high performance threads mainly distributed in UNIX but also to some Microsoft Windows OS. Threads are used in parallel programming; when a system call executes, the thread runs on an independent stream to finish its task with minimal interruptions or slowdowns. Pthreads are ideal for massive modifications to programs because the threads share one single memory space to alter a data structure, allowing constant high performance and efficiency. Pthread has become commonly used a way of adding concurrency to an application. They are widely used in UNIX; a powerful operating system written in the C language, which is continuously enhanced. Developers came across various obstacles with POSIX threads; during the beginnings of Pthreads, many technical issues had surfaced which were resolved throughout the history of POSIX threads.'''

'''The notion of threads developed naturally out of the desire for processes to communicate with each other. Threads are at a basic level multiple threads of control that share memory, and sharing memory is a relatively instantaneous method of communication. In UNIX where processes were seen as needed on a 1:1 per-terminal basis, and more about time-sharing then working together, at first this seemed relatively unnecessary[http://tinf2.vub.ac.be/~dvermeir/manuals/KDE20Development-html/ch13lev1sec2.html]. Retrieved on October 14 2010</ref>. There were after all, mechanisms in place to communicate between processes such as pipes and temporary files as well as a few "just changed" messages. The first UNIX implementation of shared memory came about in 1983 with the System V UNIX flavor, which shared memory was merely one of several upgrades to passing messages between processes.[http://fscked.org/writings/SHM/shm-5.html]'''

'''The beginning of POSIX Threads starts off with hardware sellers executing their own versions of threads[https://computing.llnl.gov/tutorials/pthreads/]. These developments varied from one another, creating difficulties for programmers to implement portable thread applications[https://computing.llnl.gov/tutorials/pthreads/]. With UNIX starting to develop shared memory as a viable Inter-process communication tool developers started to create a high demand for the ability to run multiple threads under one process. Consequently, IEEE began to form together the POSIX standards. In 1988, POSIX.1 - created to support application portability – was ratified and accepted as the international standard in 1990[http://www.opengroup.org/austin/papers/posix_faq.html][http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=0607607821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091]. After the approval, the POSIX standard grew to more than 20 individual standards, encapsulating a large area of different groups[http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=0607607821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091].'''

'''POSIX.1 lays out the interfaces for OS services; their syntax, and how they should act. However, it does not define how the interface should be implemented on the OS, allowing many different operating systems to conform to standards in their own specific design and application[http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=0607607821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091]. POSIX.2 was created for much of the same reason as POSIX.1; portable shell programming and portable program development, but describes a programmable shell and its common utilities[https://computing.llnl.gov/tutorials/pthreads/]. Although POSIX.2 improved on the original, POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto Linux; this is due to the significant differences in relationship between POSIX and UNIX. These differences include: naming conventions (identifiers, operators, etc...), parameters and variables.[http://www.unix.org/whitepapers/shdiffs.html]'''

'''In the last twenty years, several advancements took place; there was a huge leap from the basic performance and function of a standard thread to a multi-threading, high performance POSIX thread. However, before it was given recognition as being efficient with high performance, a POSIX thread had numerous setbacks and high-priority challenges. Although the basic principle of a POSIX thread within UNIX was already executed by hardware sellers, it was under different names with minor structural variations, prohibiting developers to create portable thread applications. Fortunately, these issues were resolved and POSIX threads were enhanced, with continuous improvements on the way. Developers made an extraordinary breakthrough in concurrent programming by enabling efficiency and high performance, especially during immense modifications to data structure. Even with a rough past, POSIX threads have improved to become one of the most widely-known and commonly used method of adding concurrency to an application.'''

----

=Unsorted=
(unsorted essay)

-[[User:Npatel1|Npatel1]] ; here is the first paragraph. you can edit/add more to the paragraph if needed!

-Afranco2; I put in the history section/strung in tmalone's stuff as well. Again, feel free to edit/add content

-Tmalone; Edited and corrected the information thus far. I will post a conclusion sometime tomorrow.

-[[User:Npatel1|Npatel1]] ; Trevor, last lines should get us started on the conclusion. Afranco2; i went to class today and prof. was talking about plagiarism, can you please check your paragraph and see if there is any signs of plagiarism. since i don't know where you gathered your information from. upon you completion please post on wiki; need to make some modification to the body paragraph.

-http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=6626986821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091 That is one of the sources which I used for my information. I don't believe that I am plagiarizing, but I know that it is easy to do accidentally. If somebody wants to check it over for me to make sure, that would be great. My information comes from the first and second page. I also used POSIX Threads and the Linux Kernel and a little bit from IEEE POSIX Testing Policy General Information

-[[User:Npatel1|Npatel1]] ; oh i just wanted to make sure since the prof. emphasized on it a lot last class! thanks Afranco2.

POSIX (Portable Operating System Interface) threads, are high performance threads mainly distributed in UNIX but also to some Microsoft Windows OSes. Threads are used in parallel programming; when a system call executes, the thread runs on an independent stream to finish its task with minimal interruptions or slowdowns. Pthreads (from POSIX threads) are ideal for massive modifications to programs because the threads share one single memory space to alter a data structure, allowing constant high performance and efficiency. Pthreads have become a commonly used way of adding concurrency to an application. They are widely used in UNIX; a powerful operating system written in the C language, which is continuously enhanced. Developers came across various obstacles with POSIX threads; during the beginnings of Pthreads, many technical issues had surfaced which were resolved throughout the history of POSIX threads.

The history of POSIX Threads is that many hardware sellers executed their own versions of threads. These developments differed from one another, creating difficulties for programmers to implement portable thread applications. UNIX traditionally had a system running only a single thread under a process. These processes could not share memory and interacted using 'pipes'. Once developers started wanting to be able to run multiple threads under one process, IEEE began to form together the POSIX standards. In 1988 POSIX.1 (created to support application portability) was ratified and was accepted as the international standard in 1990. From there the POSIX standards grew to more than 20 individual standards, encapsulating a large area of different groups.

POSIX.1 lays out the interfaces for OS services; their syntax, and how they should act. It however does not define how the interface should be implemented on the OS. This is made to allow many different operating systems to conform to standards in their own specific design and application. POSIX.2 was created for much the same reason as POSIX.1 (portable shell programming, portable program development) but describes a programmable shell and its common utilities.

POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto Linux; this is due to the significant differences in relationship between POSIX and UNIX.

^^^ this statement sounds a bit off. why does UNIX care what Linux can handle? - John v.

I'll look into that tomorrow; working on 3005 Assignment. John, if you have a suggestion or an add-on that you wish to provide, please do so under collaboration.

-[[User:Npatel1|Npatel1]]

Hey guys, before end of tomorrow if there is anything missing or if anyone wishes to contribute more towards the essay please do so asap.

-[[User:Npatel1|Npatel1]]

UNIX cares about what Linux can handle because POSIX threads are mainly used in Linux systems. It is a very big deal if a certain type of thread is generating countless errors on the main system type the thread is created for. And regardless of just the fact that its widely used on Linux, UNIX would care because compatibility is one of the most important things to have. For a POSIX thread to not be compatible with Linux just because UNIX didn't care, then the progress of multi-threading and POSIX threads would not be able to be used in Linux. Then Linux would not be as widely used as it would not be enhanced like other systems. It is important for systems to have that compatibility, so that they don't end up left in the dust of technology.

-[[User:Tmalone|Tmalone]]

----

One of the major reasons why UNIX was so late to implement support for the POSIX threads is the way the two define "multi-threaded" process.
Traditionally UNIX defined a process to be an instance of a running program.With POSIX this came to be defined more precisely. The 'process'
was defined to be "an address-space and a group of resources dedicated to running the program". 
POSIX defines a 'thread' as the resources neccessary for a single thread of execution ie. a single execution path. Thus according to POSIX the basic unit of execution is a thread. On the other hand UNIX traditionally defined a 'task' as the basic unit of execution which is essentially same as the POSIX definition of a 'process'. 
Now the conflict between the POSIX Threads and UNIX implementation of tasks came when a task used a clone() system call to create another task in order to implement multi-threading. The program then becomes a co-operating set of tasks which share 'some' resources. It is due to this halfway implementation of sharing of resources that lies the major conflict. In a nutshell the fundamental difference between the two is that in POSIX a process can be addressed as a single entity, while in Linux it is a collection of independent tasks. In the POSIX thread implementation all actions affect the entire process. In Linux, however, each of these actions will only affect one task.

Not from your group. But I think your essay should incorporate this too. --[[User:Gautam|Gautam]] 19:35, 14 October 2010 (UTC)

Appreciate your contribution towards the essay even though your not in our group; if its possible, can you please give us the link to which you got the information from. --[[User:Npatel1|Npatel1]]

=Collaboration=

Hey guys, i'm just gunna get this started by posting a few links for everyone to get going. This will help explain a general idea of what they are and the history of them. Please add some more links or anything else you think would be helpful!

http://en.wikipedia.org/wiki/POSIX_Threads
https://computing.llnl.gov/tutorials/pthreads/
http://sourceware.org/pthreads-win32/

-[[User:tmalone|tmalone]]

I found this, might not help, but it might:--[[User:Rannath|Rannath]] 02:09, 6 October 2010 (UTC)

I'm not sure about the rest of you, but most of what I am able to find has to do with information on things that fall under POSIX, not actually about POSIX-afranco2

POSIX Threads, or pthreads, is a thread that is commonly used in UNIX systems but it also seen in some Microsoft Windows systems. A thread is a unit of process that executes segments of code within applications. When a process gets called from the system, the thread will execute the code for the process. POSIX stands for Portable Operating System Interface (for UNIX) and has been used by many independent sellers of hardware. There has always been issues such that developers could not create a reliable protable pthread application. For the use of multi-threading, its implementation arrived fairly late because the systems could not support it. Data mapping onto Linux gave birth to several problems due to the fact that POSIX and UNIX were implemented so differently.

-[[User:tmalone|tmalone]]

http://www.faqs.org/faqs/os-research/part1/section-10.html

Might be of some use as well --[[User:Lmundt|Lmundt]] 14:48, 7 October 2010 (UTC)
https://computing.llnl.gov/tutorials/pthreads/

Edited version from what -tmalone has written.

POSIX Threads is also called pthreads. Portable Operating System interface; mainly for Unix but it’s also distributed to some Microsoft Windows OS. A Thread is a unit of process that resides inside a process and executes when a system call has been executed. Threads have same global and all the threads share memory, threads also contain their personal private data. Pthread has become commonly used a way of adding concurrency to an application. The history of POSIX Threads is that many hardware sellers executed their own versions of threads. These developments differed from one another, creating difficulties for programmers to implement portable thread applications. POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto linux; this is due to the significant differences in relationship between POSIX and UNIX.

-Npatel1

A bit different of a explanation of the history of threads in Unix:

Originally in UNIX things similar to threads existed, they were however, called processes. The “processes” shared memory and used semaphores and thus “threads” have been around from the start. However, they disappeared when UNIX took the multics definition of process to mean they should not share memory, and all of sudden the ability to have threads disappeared. As people clamored to have the good old processes back, they created a new thing called “threads” that was actually what they had previously. So while it seemed they were late to support multithreaded processes, in reality they merely had a brief period where they didn’t have multi-threadedness.

-[[User:Rift|Rift]] 23:42, 10 October 2010 (UTC)

Here is a possible simple conclusion I've typed up. I used the first chunk of Rifts paragraph then just threw in some extra info. Go easy on me lol

Originally in UNIX things similar to threads existed, they were however, called processes. The “processes” shared memory and used semaphores and thus “threads” have been around from the start. However, they disappeared when UNIX took the multics definition of process to mean they should not share memory, and all of sudden the ability to have threads disappeared. What are now considered POSIX threads have just been aliased for many years. The late implementation of these threads was because of the fact that so many developers had the basic principle of a POSIX thread in use, it was simply under a different name with minor structural differences. It is quite evident how POSIX threads came to be over the years especially within the UNIX system. From the basic performance and function of a standard thread to the multi-threading abilities of the POSIX thread, the development became more and more concrete. Though problems arose, such as creating portable thread applications between developers, solutions were found. POSIX.1 and POSIX.2 were created to display interfaces with specific syntax and to describe programming shells for many operating systems. Given the last 20 years when the leap was taken between a standard thread and a POSIX thread, and the speed in which the POSIX thread has been implemented, it can be said that given another 20 years the POSIX thread will have turned into something even more worth the wait.

Okay guys this is a conclusion I've typed up. I have absolutely no idea if this is good enough, I find it pretty tough to write conclusions. Nonetheless, feel free to make changes and add/delete whatever you want. I'm not sure how formal he wants it to be, but I hope this is at least decent. If you want me to make some changes let me know what to change and I'll do it asap.

(I constantly make changes myself :p)

- Tmalone

==References==

http://www.unix.org/whitepapers/shdiffs.html

http://en.wikipedia.org/wiki/POSIX_Threads

http://sourceware.org/pthreads-win32/

https://computing.llnl.gov/tutorials/pthreads/

http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf

http://www.drdobbs.com/open-source/184406204;jsessionid=GKSVKT3EOMUBDQE1GHRSKHWATMY32JVN

Talk:COMP 3000 Essay 1 2010 Question 8

2010-10-14T18:58:44Z

Tmalone: /* Question clarification */

==Question clarification==

To answer this question properly you need to discuss where pthreads came from. The UNIX process model came out in the early 1970's, pthreads was only really proposed in the late 1980's. That's 10-15 years of history, what was happening? What about the general development of threads in CS? Alternative pthread implementations (who had the first one? what was the first kernel-based one?). I know that the history of pthreads on linux is kind of complicated - see the [http://en.wikipedia.org/wiki/Native_POSIX_Thread_Library NPTL]. You don't need to talk about all of this - but you do need to go beyond just what happened with the pthread standard. --[[User:Soma|Anil]]

- UNIX was born in 1969

- Began on a PDP-11/20 machine with a text formatting program called roff and a text editor

- Was rewritten in C in 1972 -> brought forth more portable software

- Became available to Universities and commercial firms as well as the US Government

- Many editions of UNIX came out, by 1975 Versions 4, 5, and 6 were released

- The new versions added the concept of pipes -> led to more modular code-base and faster development cycle

- Pipeline is a chain of processes together by streams, so that the output of one process is the input of the next

- Became more and more portable

- In 1979, UNIX Version 7 was released

- Several more Versions 8, 9, and 10 released the in 80's

- Early UNIX had a 'process', which was essentially a thread of control, with a virtual address space

- Interacted through pipes because they could not share

- After a while, UNIX wanted processes that shared memory, bringing the invention of the thread

- Also called lightweight in contrast to the heavyweight processes before it

- This is dated around the late 1970's and the early 80's, and example is the microkernel

- Alternative Pthread implementation in the 4.0 Digital UNIX, known as DEC OSF/1
- It was a part of the Mach OS

- Pthread library schedules threads at a one-to-one relationship, all threads fight other threads, not threads of the same process.

- Good for priority, if priority is increased, so is the function of the specific process

- Doesn't limit a program to a single executing thread, many threads in a program can run on different CPU's

- NPTL (Native POSIX Thread Library) is software that enables the Linux kernel to run programs using POSIX threads efficiently

- Has become a part of the Linux kernel since Version 2.6 (Version 1 began around 1996)

- Was a massive improvement from LinuxThreads, which had no real support for threads

- NPTL was first released in Red Hat Linux 9

- Threads are still created with clone() system call and futex primitive is used to implement locking

http://en.wikipedia.org/wiki/Pipeline_%28Unix%29

http://en.wikipedia.org/wiki/Unix#1970s

http://books.google.ca/books?id=EZfElJsWCqgC&pg=PA198&lpg=PA198&dq=kernel+based+pthreads&source=bl&ots=3HFKw_0nqq&sig=P0L9feIb88xJRzQfLd7maKtVnTU&hl=en&ei=Oky3TM-_OaO0nAf1-YiwCA&sa=X&oi=book_result&ct=result&resnum=6&ved=0CCsQ6AEwBQ#v=onepage&q=kernel%20based%20pthreads&f=false

http://en.wikipedia.org/wiki/Native_POSIX_Thread_Library

http://www.faqs.org/faqs/os-research/part1/section-10.html

- Tmalone

== Group 8 ==

'''GROUP NAMES:'''

Niravkumar Patel (Npatel1)

Trevor Malone (Tmalone)

Mark Walts (Rift)

John Vanden Heuvel (jvheuvel)

Jeff Francom (Afranco2)

== Discussion ==

[http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf POSIX Threads and the Linux Kernel] --[[User:Gautam|Gautam]] 23:52, 5 October 2010 (UTC)

Not from your group. However I found a webpage which you might find useful.
[http://www.drdobbs.com/open-source/184406204;jsessionid=3MRSO5YMO1QVRQE1GHRSKHWATMY32JVN The New Implementation of Threads for Linux]
--[[User:Gautam|Gautam]] 22:56, 5 October 2010 (UTC)

Not extremely helpful but: [http://www.unix.com/unix-dummies-questions-answers/7-short-history-unix-l-madden-ic-ac-uk.html A short history of unix] [[User:Rift|Rift]] 18:30, 7 October 2010 (UTC)

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf IEEE POSIX Testing Policy General Information
The POSIX family of standards, Stephen R. Walli
-afranco2

I'm not sure how we are planning on structuring this essay, but I will just write a bit on the history of Posix part for now. Does somebody want to handle writing an intro? - afranco2

Hey guys, sorry for the late reply...
i just wanted everyone to finish their assignment portion. we would have our own set of explanation for question 8.

AFRANCO2; Here is a suggestion.

1st paragraph;
should consist defining UNIX and POSIX/Threads

2nd paragrah;
consisting the history behind POSIX and why UNIX was so late to implement the support of multithreaded processes.

3rd paragraph;
should conclude it all.

I agree, but I don't think that we should limit it to specifically 'paragraphs' but rather sections. -afranco2

Here is a site that would take care of paragraph 1:
https://computing.llnl.gov/tutorials/pthreads/

GAUTHAM provided us with very useful pdf. that talks about the history of POSIX.

-[[User:Npatel1|Npatel1]]

This may be a stupid question, buy does anybody know what we have to do for citation? Are we using footnotes like a regular wiki? Or is there another conformation we need to follow? -afranco2

--footnotes are probably easiest, John v.

I'll take care of the first paragraph if you guys are comfortable with the structure of the essay (post it by the end of today). since we already have AFRANCO2 who did the history portion of the essay.

I made a new tab for "ESSAY" final copy*

-[[User:Npatel1|Npatel1]]

I'm not sure about the citations; just keep the links you used to gather the information, we'll ask him on Tuesday.
(i was just wondering, is this is the kind of structure you were looking for? or should we change the structure?)

-[[User:Npatel1|Npatel1]]

So what all do we need left? Sorry I am out of town trying to keep up as much as possible. Ive posted my research content on the primary page. And I've noticed we are getting pretty organized with our essay format. Just as an update process what has been completed and what is left to do? Because i don't wanna type up a bunch of information we may not need anymore. So Whatever else we need I can type up with all our info and then we can out the together the essay in the next couple days.

- Tmalone

And I think the structure is a good idea. We have enough information to turn it all into a good essay. If you have another suggestion on the structure though by all means tell us what you think.

- Tmalone

sounds good! I'm sorry i was unable to post the Intro today...
I'll make sure to have it by tomorrow!

Tmalone, i think we have good portion for History; i will get us started with a good intro then link in the history as our second paragraph which afranco2 has provided. then we'll talk about why UNIX was soo late; finally conclude it all with a last paragraph.

-[[User:Npatel1|Npatel1]]

Alright, I'll get started on a possible conclusion format. Then we can post it all and edit and add/delete whatever we want. So then hopefully by Tuesdays class we will have a good make-up of the essay we want.

- Tmalone

I read the current essay format posted. It was really well done good job guys. I read over it and corrected some minor grammar errors. So by sometime tomorrow I'll have a possible conclusion paragraph posted. If anyone else wants to type anything up for a conclusion they can feel free to as well! The more the better.

- Tmalone

It's looking good. Sorry if i'm a bit late to the party. I threw a paragraph down in the answer part. I know it doesn't really fit well.. but it really nees to get worked in.. -Rift

little late here too, got sidetracked with 3004 and 3008. I do have a concern in that 3 paragraphs really isn't an essay, he seemed to want more than that JOhn v.

anyone remember what was cited where in the essay? we're still missing references -- John

yeah, Tmalone decided that he was going to do the citation suitable to the essay. Feel free to help; upon finishing, we'll post it on the "page". Nothing fancy, Prof. Anil mentioned that he just wanted the basic format. John, the information that was cited is in discussion and also in collaboration. -[[User:Npatel1|Npatel1]]

I cited a few things and added a small paragraph. It's really hard to find things/events relating to it.. [[User:Rift|Rift]] 15:12, 14 October 2010 (UTC)

== Sources ==

Everyone please post any extra links here;
we'll organize it after everyone posts their links.

posted the ones that are provided on our discussion.

-[[User:Npatel1|Npatel1]]

http://www.unix.org/whitepapers/shdiffs.html

http://en.wikipedia.org/wiki/POSIX_Threads

http://sourceware.org/pthreads-win32/

https://computing.llnl.gov/tutorials/pthreads/

http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf

http://www.drdobbs.com/open-source/184406204;jsessionid=GKSVKT3EOMUBDQE1GHRSKHWATMY32JVN

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf

http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=6626986821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091

Journal article "Achieving Efficiency and Portability in Systems Software: A Case Study on POSIX-Compliant Multithreaded Programs" http://dx.doi.org.proxy.library.carleton.ca/10.1109/TSE.2005.98

Talk:COMP 3000 Essay 1 2010 Question 8

2010-10-14T18:58:30Z

Tmalone: /* Question clarification */

==Question clarification==

To answer this question properly you need to discuss where pthreads came from. The UNIX process model came out in the early 1970's, pthreads was only really proposed in the late 1980's. That's 10-15 years of history, what was happening? What about the general development of threads in CS? Alternative pthread implementations (who had the first one? what was the first kernel-based one?). I know that the history of pthreads on linux is kind of complicated - see the [http://en.wikipedia.org/wiki/Native_POSIX_Thread_Library NPTL]. You don't need to talk about all of this - but you do need to go beyond just what happened with the pthread standard. --[[User:Soma|Anil]]

- UNIX was born in 1969

- Began on a PDP-11/20 machine with a text formatting program called roff and a text editor

- Was rewritten in C in 1972 -> brought forth more portable software

- Became available to Universities and commercial firms as well as the US Government

- Many editions of UNIX came out, by 1975 Versions 4, 5, and 6 were released

- The new versions added the concept of pipes -> led to more modular code-base and faster development cycle

- Pipeline is a chain of processes together by streams, so that the output of one process is the input of the next

- Became more and more portable

- In 1979, UNIX Version 7 was released

- Several more Versions 8, 9, and 10 released the in 80's

- Early UNIX had a 'process', which was essentially a thread of control, with a virtual address space

- Interacted through pipes because they could not share

- After a while, UNIX wanted processes that shared memory, bringing the invention of the thread

- Also called lightweight in contrast to the heavyweight processes before it

- This is dated around the late 1970's and the early 80's, and example is the microkernel

- Alternative Pthread implementation in the 4.0 Digital UNIX, known as DEC OSF/1
- It was a part of the Mach OS

- Pthread library schedules threads at a one-to-one relationship, all threads fight other threads, not threads of the same process.

- Good for priority, if priority is increased, so is the function of the specific process

- Doesn't limit a program to a single executing thread, many threads in a program can run on different CPU's

- NPTL (Native POSIX Thread Library) is software that enables the Linux kernel to run programs using POSIX threads efficiently

- Has become a part of the Linux kernel since Version 2.6 (Version 1 began around 1996)

- Was a massive improvement from LinuxThreads, which had no real support for threads

- NPTL was first released in Red Hat Linux 9

- Threads are still created with clone() system call and futex primitive is used to implement locking

http://en.wikipedia.org/wiki/Pipeline_%28Unix%29
http://en.wikipedia.org/wiki/Unix#1970s
http://books.google.ca/books?id=EZfElJsWCqgC&pg=PA198&lpg=PA198&dq=kernel+based+pthreads&source=bl&ots=3HFKw_0nqq&sig=P0L9feIb88xJRzQfLd7maKtVnTU&hl=en&ei=Oky3TM-_OaO0nAf1-YiwCA&sa=X&oi=book_result&ct=result&resnum=6&ved=0CCsQ6AEwBQ#v=onepage&q=kernel%20based%20pthreads&f=false
http://en.wikipedia.org/wiki/Native_POSIX_Thread_Library
http://www.faqs.org/faqs/os-research/part1/section-10.html

- Tmalone

== Group 8 ==

'''GROUP NAMES:'''

Niravkumar Patel (Npatel1)

Trevor Malone (Tmalone)

Mark Walts (Rift)

John Vanden Heuvel (jvheuvel)

Jeff Francom (Afranco2)

== Discussion ==

[http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf POSIX Threads and the Linux Kernel] --[[User:Gautam|Gautam]] 23:52, 5 October 2010 (UTC)

Not from your group. However I found a webpage which you might find useful.
[http://www.drdobbs.com/open-source/184406204;jsessionid=3MRSO5YMO1QVRQE1GHRSKHWATMY32JVN The New Implementation of Threads for Linux]
--[[User:Gautam|Gautam]] 22:56, 5 October 2010 (UTC)

Not extremely helpful but: [http://www.unix.com/unix-dummies-questions-answers/7-short-history-unix-l-madden-ic-ac-uk.html A short history of unix] [[User:Rift|Rift]] 18:30, 7 October 2010 (UTC)

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf IEEE POSIX Testing Policy General Information
The POSIX family of standards, Stephen R. Walli
-afranco2

I'm not sure how we are planning on structuring this essay, but I will just write a bit on the history of Posix part for now. Does somebody want to handle writing an intro? - afranco2

Hey guys, sorry for the late reply...
i just wanted everyone to finish their assignment portion. we would have our own set of explanation for question 8.

AFRANCO2; Here is a suggestion.

1st paragraph;
should consist defining UNIX and POSIX/Threads

2nd paragrah;
consisting the history behind POSIX and why UNIX was so late to implement the support of multithreaded processes.

3rd paragraph;
should conclude it all.

I agree, but I don't think that we should limit it to specifically 'paragraphs' but rather sections. -afranco2

Here is a site that would take care of paragraph 1:
https://computing.llnl.gov/tutorials/pthreads/

GAUTHAM provided us with very useful pdf. that talks about the history of POSIX.

-[[User:Npatel1|Npatel1]]

This may be a stupid question, buy does anybody know what we have to do for citation? Are we using footnotes like a regular wiki? Or is there another conformation we need to follow? -afranco2

--footnotes are probably easiest, John v.

I'll take care of the first paragraph if you guys are comfortable with the structure of the essay (post it by the end of today). since we already have AFRANCO2 who did the history portion of the essay.

I made a new tab for "ESSAY" final copy*

-[[User:Npatel1|Npatel1]]

I'm not sure about the citations; just keep the links you used to gather the information, we'll ask him on Tuesday.
(i was just wondering, is this is the kind of structure you were looking for? or should we change the structure?)

-[[User:Npatel1|Npatel1]]

So what all do we need left? Sorry I am out of town trying to keep up as much as possible. Ive posted my research content on the primary page. And I've noticed we are getting pretty organized with our essay format. Just as an update process what has been completed and what is left to do? Because i don't wanna type up a bunch of information we may not need anymore. So Whatever else we need I can type up with all our info and then we can out the together the essay in the next couple days.

- Tmalone

And I think the structure is a good idea. We have enough information to turn it all into a good essay. If you have another suggestion on the structure though by all means tell us what you think.

- Tmalone

sounds good! I'm sorry i was unable to post the Intro today...
I'll make sure to have it by tomorrow!

Tmalone, i think we have good portion for History; i will get us started with a good intro then link in the history as our second paragraph which afranco2 has provided. then we'll talk about why UNIX was soo late; finally conclude it all with a last paragraph.

-[[User:Npatel1|Npatel1]]

Alright, I'll get started on a possible conclusion format. Then we can post it all and edit and add/delete whatever we want. So then hopefully by Tuesdays class we will have a good make-up of the essay we want.

- Tmalone

I read the current essay format posted. It was really well done good job guys. I read over it and corrected some minor grammar errors. So by sometime tomorrow I'll have a possible conclusion paragraph posted. If anyone else wants to type anything up for a conclusion they can feel free to as well! The more the better.

- Tmalone

It's looking good. Sorry if i'm a bit late to the party. I threw a paragraph down in the answer part. I know it doesn't really fit well.. but it really nees to get worked in.. -Rift

little late here too, got sidetracked with 3004 and 3008. I do have a concern in that 3 paragraphs really isn't an essay, he seemed to want more than that JOhn v.

anyone remember what was cited where in the essay? we're still missing references -- John

yeah, Tmalone decided that he was going to do the citation suitable to the essay. Feel free to help; upon finishing, we'll post it on the "page". Nothing fancy, Prof. Anil mentioned that he just wanted the basic format. John, the information that was cited is in discussion and also in collaboration. -[[User:Npatel1|Npatel1]]

I cited a few things and added a small paragraph. It's really hard to find things/events relating to it.. [[User:Rift|Rift]] 15:12, 14 October 2010 (UTC)

== Sources ==

Everyone please post any extra links here;
we'll organize it after everyone posts their links.

posted the ones that are provided on our discussion.

-[[User:Npatel1|Npatel1]]

http://www.unix.org/whitepapers/shdiffs.html

http://en.wikipedia.org/wiki/POSIX_Threads

http://sourceware.org/pthreads-win32/

https://computing.llnl.gov/tutorials/pthreads/

http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf

http://www.drdobbs.com/open-source/184406204;jsessionid=GKSVKT3EOMUBDQE1GHRSKHWATMY32JVN

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf

http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=6626986821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091

Journal article "Achieving Efficiency and Portability in Systems Software: A Case Study on POSIX-Compliant Multithreaded Programs" http://dx.doi.org.proxy.library.carleton.ca/10.1109/TSE.2005.98

Talk:COMP 3000 Essay 1 2010 Question 8

2010-10-14T18:57:14Z

Tmalone: /* Answers */

==Question clarification==

To answer this question properly you need to discuss where pthreads came from. The UNIX process model came out in the early 1970's, pthreads was only really proposed in the late 1980's. That's 10-15 years of history, what was happening? What about the general development of threads in CS? Alternative pthread implementations (who had the first one? what was the first kernel-based one?). I know that the history of pthreads on linux is kind of complicated - see the [http://en.wikipedia.org/wiki/Native_POSIX_Thread_Library NPTL]. You don't need to talk about all of this - but you do need to go beyond just what happened with the pthread standard. --[[User:Soma|Anil]]

- UNIX was born in 1969
- Began on a PDP-11/20 machine with a text formatting program called roff and a text editor
- Was rewritten in C in 1972 -> brought forth more portable software
- Became available to Universities and commercial firms as well as the US Government
- Many editions of UNIX came out, by 1975 Versions 4, 5, and 6 were released
- The new versions added the concept of pipes -> led to more modular code-base and faster development cycle
- Pipeline is a chain of processes together by streams, so that the output of one process is the input of the next
- Became more and more portable
- In 1979, UNIX Version 7 was released
- Several more Versions 8, 9, and 10 released the in 80's

- Early UNIX had a 'process', which was essentially a thread of control, with a virtual address space
- Interacted through pipes because they could not share
- After a while, UNIX wanted processes that shared memory, bringing the invention of the thread
- Also called lightweight in contrast to the heavyweight processes before it
- This is dated around the late 1970's and the early 80's, and example is the microkernel

- Alternative Pthread implementation in the 4.0 Digital UNIX, known as DEC OSF/1
- It was a part of the Mach OS
- Pthread library schedules threads at a one-to-one relationship, all threads fight other threads, not threads of the same process.
- Good for priority, if priority is increased, so is the function of the specific process
- Doesn't limit a program to a single executing thread, many threads in a program can run on different CPU's

- NPTL (Native POSIX Thread Library) is software that enables the Linux kernel to run programs using POSIX threads efficiently
- Has become a part of the Linux kernel since Version 2.6 (Version 1 began around 1996)
- Was a massive improvement from LinuxThreads, which had no real support for threads
- NPTL was first released in Red Hat Linux 9
- Threads are still created with clone() system call and futex primitive is used to implement locking

http://en.wikipedia.org/wiki/Pipeline_%28Unix%29
http://en.wikipedia.org/wiki/Unix#1970s
http://books.google.ca/books?id=EZfElJsWCqgC&pg=PA198&lpg=PA198&dq=kernel+based+pthreads&source=bl&ots=3HFKw_0nqq&sig=P0L9feIb88xJRzQfLd7maKtVnTU&hl=en&ei=Oky3TM-_OaO0nAf1-YiwCA&sa=X&oi=book_result&ct=result&resnum=6&ved=0CCsQ6AEwBQ#v=onepage&q=kernel%20based%20pthreads&f=false
http://en.wikipedia.org/wiki/Native_POSIX_Thread_Library
http://www.faqs.org/faqs/os-research/part1/section-10.html

- Tmalone

== Group 8 ==

'''GROUP NAMES:'''

Niravkumar Patel (Npatel1)

Trevor Malone (Tmalone)

Mark Walts (Rift)

John Vanden Heuvel (jvheuvel)

Jeff Francom (Afranco2)

== Discussion ==

[http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf POSIX Threads and the Linux Kernel] --[[User:Gautam|Gautam]] 23:52, 5 October 2010 (UTC)

Not from your group. However I found a webpage which you might find useful.
[http://www.drdobbs.com/open-source/184406204;jsessionid=3MRSO5YMO1QVRQE1GHRSKHWATMY32JVN The New Implementation of Threads for Linux]
--[[User:Gautam|Gautam]] 22:56, 5 October 2010 (UTC)

Not extremely helpful but: [http://www.unix.com/unix-dummies-questions-answers/7-short-history-unix-l-madden-ic-ac-uk.html A short history of unix] [[User:Rift|Rift]] 18:30, 7 October 2010 (UTC)

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf IEEE POSIX Testing Policy General Information
The POSIX family of standards, Stephen R. Walli
-afranco2

I'm not sure how we are planning on structuring this essay, but I will just write a bit on the history of Posix part for now. Does somebody want to handle writing an intro? - afranco2

Hey guys, sorry for the late reply...
i just wanted everyone to finish their assignment portion. we would have our own set of explanation for question 8.

AFRANCO2; Here is a suggestion.

1st paragraph;
should consist defining UNIX and POSIX/Threads

2nd paragrah;
consisting the history behind POSIX and why UNIX was so late to implement the support of multithreaded processes.

3rd paragraph;
should conclude it all.

I agree, but I don't think that we should limit it to specifically 'paragraphs' but rather sections. -afranco2

Here is a site that would take care of paragraph 1:
https://computing.llnl.gov/tutorials/pthreads/

GAUTHAM provided us with very useful pdf. that talks about the history of POSIX.

-[[User:Npatel1|Npatel1]]

This may be a stupid question, buy does anybody know what we have to do for citation? Are we using footnotes like a regular wiki? Or is there another conformation we need to follow? -afranco2

--footnotes are probably easiest, John v.

I'll take care of the first paragraph if you guys are comfortable with the structure of the essay (post it by the end of today). since we already have AFRANCO2 who did the history portion of the essay.

I made a new tab for "ESSAY" final copy*

-[[User:Npatel1|Npatel1]]

I'm not sure about the citations; just keep the links you used to gather the information, we'll ask him on Tuesday.
(i was just wondering, is this is the kind of structure you were looking for? or should we change the structure?)

-[[User:Npatel1|Npatel1]]

So what all do we need left? Sorry I am out of town trying to keep up as much as possible. Ive posted my research content on the primary page. And I've noticed we are getting pretty organized with our essay format. Just as an update process what has been completed and what is left to do? Because i don't wanna type up a bunch of information we may not need anymore. So Whatever else we need I can type up with all our info and then we can out the together the essay in the next couple days.

- Tmalone

And I think the structure is a good idea. We have enough information to turn it all into a good essay. If you have another suggestion on the structure though by all means tell us what you think.

- Tmalone

sounds good! I'm sorry i was unable to post the Intro today...
I'll make sure to have it by tomorrow!

Tmalone, i think we have good portion for History; i will get us started with a good intro then link in the history as our second paragraph which afranco2 has provided. then we'll talk about why UNIX was soo late; finally conclude it all with a last paragraph.

-[[User:Npatel1|Npatel1]]

Alright, I'll get started on a possible conclusion format. Then we can post it all and edit and add/delete whatever we want. So then hopefully by Tuesdays class we will have a good make-up of the essay we want.

- Tmalone

I read the current essay format posted. It was really well done good job guys. I read over it and corrected some minor grammar errors. So by sometime tomorrow I'll have a possible conclusion paragraph posted. If anyone else wants to type anything up for a conclusion they can feel free to as well! The more the better.

- Tmalone

It's looking good. Sorry if i'm a bit late to the party. I threw a paragraph down in the answer part. I know it doesn't really fit well.. but it really nees to get worked in.. -Rift

little late here too, got sidetracked with 3004 and 3008. I do have a concern in that 3 paragraphs really isn't an essay, he seemed to want more than that JOhn v.

anyone remember what was cited where in the essay? we're still missing references -- John

yeah, Tmalone decided that he was going to do the citation suitable to the essay. Feel free to help; upon finishing, we'll post it on the "page". Nothing fancy, Prof. Anil mentioned that he just wanted the basic format. John, the information that was cited is in discussion and also in collaboration. -[[User:Npatel1|Npatel1]]

I cited a few things and added a small paragraph. It's really hard to find things/events relating to it.. [[User:Rift|Rift]] 15:12, 14 October 2010 (UTC)

== Sources ==

Everyone please post any extra links here;
we'll organize it after everyone posts their links.

posted the ones that are provided on our discussion.

-[[User:Npatel1|Npatel1]]

http://www.unix.org/whitepapers/shdiffs.html

http://en.wikipedia.org/wiki/POSIX_Threads

http://sourceware.org/pthreads-win32/

https://computing.llnl.gov/tutorials/pthreads/

http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf

http://www.drdobbs.com/open-source/184406204;jsessionid=GKSVKT3EOMUBDQE1GHRSKHWATMY32JVN

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf

http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=6626986821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091

Journal article "Achieving Efficiency and Portability in Systems Software: A Case Study on POSIX-Compliant Multithreaded Programs" http://dx.doi.org.proxy.library.carleton.ca/10.1109/TSE.2005.98

Talk:COMP 3000 Essay 1 2010 Question 8

2010-10-14T18:57:01Z

Tmalone: /* Question clarification */

==Question clarification==

To answer this question properly you need to discuss where pthreads came from. The UNIX process model came out in the early 1970's, pthreads was only really proposed in the late 1980's. That's 10-15 years of history, what was happening? What about the general development of threads in CS? Alternative pthread implementations (who had the first one? what was the first kernel-based one?). I know that the history of pthreads on linux is kind of complicated - see the [http://en.wikipedia.org/wiki/Native_POSIX_Thread_Library NPTL]. You don't need to talk about all of this - but you do need to go beyond just what happened with the pthread standard. --[[User:Soma|Anil]]

==Answers==

- UNIX was born in 1969
- Began on a PDP-11/20 machine with a text formatting program called roff and a text editor
- Was rewritten in C in 1972 -> brought forth more portable software
- Became available to Universities and commercial firms as well as the US Government
- Many editions of UNIX came out, by 1975 Versions 4, 5, and 6 were released
- The new versions added the concept of pipes -> led to more modular code-base and faster development cycle
- Pipeline is a chain of processes together by streams, so that the output of one process is the input of the next
- Became more and more portable
- In 1979, UNIX Version 7 was released
- Several more Versions 8, 9, and 10 released the in 80's

- Early UNIX had a 'process', which was essentially a thread of control, with a virtual address space
- Interacted through pipes because they could not share
- After a while, UNIX wanted processes that shared memory, bringing the invention of the thread
- Also called lightweight in contrast to the heavyweight processes before it
- This is dated around the late 1970's and the early 80's, and example is the microkernel

- Alternative Pthread implementation in the 4.0 Digital UNIX, known as DEC OSF/1
- It was a part of the Mach OS
- Pthread library schedules threads at a one-to-one relationship, all threads fight other threads, not threads of the same process.
- Good for priority, if priority is increased, so is the function of the specific process
- Doesn't limit a program to a single executing thread, many threads in a program can run on different CPU's

- NPTL (Native POSIX Thread Library) is software that enables the Linux kernel to run programs using POSIX threads efficiently
- Has become a part of the Linux kernel since Version 2.6 (Version 1 began around 1996)
- Was a massive improvement from LinuxThreads, which had no real support for threads
- NPTL was first released in Red Hat Linux 9
- Threads are still created with clone() system call and futex primitive is used to implement locking

http://en.wikipedia.org/wiki/Pipeline_%28Unix%29
http://en.wikipedia.org/wiki/Unix#1970s
http://books.google.ca/books?id=EZfElJsWCqgC&pg=PA198&lpg=PA198&dq=kernel+based+pthreads&source=bl&ots=3HFKw_0nqq&sig=P0L9feIb88xJRzQfLd7maKtVnTU&hl=en&ei=Oky3TM-_OaO0nAf1-YiwCA&sa=X&oi=book_result&ct=result&resnum=6&ved=0CCsQ6AEwBQ#v=onepage&q=kernel%20based%20pthreads&f=false
http://en.wikipedia.org/wiki/Native_POSIX_Thread_Library
http://www.faqs.org/faqs/os-research/part1/section-10.html

- Tmalone

== Group 8 ==

'''GROUP NAMES:'''

Niravkumar Patel (Npatel1)

Trevor Malone (Tmalone)

Mark Walts (Rift)

John Vanden Heuvel (jvheuvel)

Jeff Francom (Afranco2)

== Discussion ==

[http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf POSIX Threads and the Linux Kernel] --[[User:Gautam|Gautam]] 23:52, 5 October 2010 (UTC)

Not from your group. However I found a webpage which you might find useful.
[http://www.drdobbs.com/open-source/184406204;jsessionid=3MRSO5YMO1QVRQE1GHRSKHWATMY32JVN The New Implementation of Threads for Linux]
--[[User:Gautam|Gautam]] 22:56, 5 October 2010 (UTC)

Not extremely helpful but: [http://www.unix.com/unix-dummies-questions-answers/7-short-history-unix-l-madden-ic-ac-uk.html A short history of unix] [[User:Rift|Rift]] 18:30, 7 October 2010 (UTC)

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf IEEE POSIX Testing Policy General Information
The POSIX family of standards, Stephen R. Walli
-afranco2

I'm not sure how we are planning on structuring this essay, but I will just write a bit on the history of Posix part for now. Does somebody want to handle writing an intro? - afranco2

Hey guys, sorry for the late reply...
i just wanted everyone to finish their assignment portion. we would have our own set of explanation for question 8.

AFRANCO2; Here is a suggestion.

1st paragraph;
should consist defining UNIX and POSIX/Threads

2nd paragrah;
consisting the history behind POSIX and why UNIX was so late to implement the support of multithreaded processes.

3rd paragraph;
should conclude it all.

I agree, but I don't think that we should limit it to specifically 'paragraphs' but rather sections. -afranco2

Here is a site that would take care of paragraph 1:
https://computing.llnl.gov/tutorials/pthreads/

GAUTHAM provided us with very useful pdf. that talks about the history of POSIX.

-[[User:Npatel1|Npatel1]]

This may be a stupid question, buy does anybody know what we have to do for citation? Are we using footnotes like a regular wiki? Or is there another conformation we need to follow? -afranco2

--footnotes are probably easiest, John v.

I'll take care of the first paragraph if you guys are comfortable with the structure of the essay (post it by the end of today). since we already have AFRANCO2 who did the history portion of the essay.

I made a new tab for "ESSAY" final copy*

-[[User:Npatel1|Npatel1]]

I'm not sure about the citations; just keep the links you used to gather the information, we'll ask him on Tuesday.
(i was just wondering, is this is the kind of structure you were looking for? or should we change the structure?)

-[[User:Npatel1|Npatel1]]

So what all do we need left? Sorry I am out of town trying to keep up as much as possible. Ive posted my research content on the primary page. And I've noticed we are getting pretty organized with our essay format. Just as an update process what has been completed and what is left to do? Because i don't wanna type up a bunch of information we may not need anymore. So Whatever else we need I can type up with all our info and then we can out the together the essay in the next couple days.

- Tmalone

And I think the structure is a good idea. We have enough information to turn it all into a good essay. If you have another suggestion on the structure though by all means tell us what you think.

- Tmalone

sounds good! I'm sorry i was unable to post the Intro today...
I'll make sure to have it by tomorrow!

Tmalone, i think we have good portion for History; i will get us started with a good intro then link in the history as our second paragraph which afranco2 has provided. then we'll talk about why UNIX was soo late; finally conclude it all with a last paragraph.

-[[User:Npatel1|Npatel1]]

Alright, I'll get started on a possible conclusion format. Then we can post it all and edit and add/delete whatever we want. So then hopefully by Tuesdays class we will have a good make-up of the essay we want.

- Tmalone

I read the current essay format posted. It was really well done good job guys. I read over it and corrected some minor grammar errors. So by sometime tomorrow I'll have a possible conclusion paragraph posted. If anyone else wants to type anything up for a conclusion they can feel free to as well! The more the better.

- Tmalone

It's looking good. Sorry if i'm a bit late to the party. I threw a paragraph down in the answer part. I know it doesn't really fit well.. but it really nees to get worked in.. -Rift

little late here too, got sidetracked with 3004 and 3008. I do have a concern in that 3 paragraphs really isn't an essay, he seemed to want more than that JOhn v.

anyone remember what was cited where in the essay? we're still missing references -- John

yeah, Tmalone decided that he was going to do the citation suitable to the essay. Feel free to help; upon finishing, we'll post it on the "page". Nothing fancy, Prof. Anil mentioned that he just wanted the basic format. John, the information that was cited is in discussion and also in collaboration. -[[User:Npatel1|Npatel1]]

I cited a few things and added a small paragraph. It's really hard to find things/events relating to it.. [[User:Rift|Rift]] 15:12, 14 October 2010 (UTC)

== Sources ==

Everyone please post any extra links here;
we'll organize it after everyone posts their links.

posted the ones that are provided on our discussion.

-[[User:Npatel1|Npatel1]]

http://www.unix.org/whitepapers/shdiffs.html

http://en.wikipedia.org/wiki/POSIX_Threads

http://sourceware.org/pthreads-win32/

https://computing.llnl.gov/tutorials/pthreads/

http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf

http://www.drdobbs.com/open-source/184406204;jsessionid=GKSVKT3EOMUBDQE1GHRSKHWATMY32JVN

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf

http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=6626986821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091

Journal article "Achieving Efficiency and Portability in Systems Software: A Case Study on POSIX-Compliant Multithreaded Programs" http://dx.doi.org.proxy.library.carleton.ca/10.1109/TSE.2005.98

Talk:COMP 3000 Essay 1 2010 Question 8

2010-10-14T13:24:57Z

Tmalone: /* Sources */

== Group 8 ==

'''GROUP NAMES:'''

Niravkumar Patel (Npatel1)

Trevor Malone (Tmalone)

Mark Walts (Rift)

John Vanden Heuvel (jvheuvel)

Jeff Francom (Afranco2)

== Discussion ==

[http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf POSIX Threads and the Linux Kernel] --[[User:Gautam|Gautam]] 23:52, 5 October 2010 (UTC)

Not from your group. However I found a webpage which you might find useful.
[http://www.drdobbs.com/open-source/184406204;jsessionid=3MRSO5YMO1QVRQE1GHRSKHWATMY32JVN The New Implementation of Threads for Linux]
--[[User:Gautam|Gautam]] 22:56, 5 October 2010 (UTC)

Not extremely helpful but: [http://www.unix.com/unix-dummies-questions-answers/7-short-history-unix-l-madden-ic-ac-uk.html A short history of unix] [[User:Rift|Rift]] 18:30, 7 October 2010 (UTC)

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf IEEE POSIX Testing Policy General Information
The POSIX family of standards, Stephen R. Walli
-afranco2

I'm not sure how we are planning on structuring this essay, but I will just write a bit on the history of Posix part for now. Does somebody want to handle writing an intro? - afranco2

Hey guys, sorry for the late reply...
i just wanted everyone to finish their assignment portion. we would have our own set of explanation for question 8.

AFRANCO2; Here is a suggestion.

1st paragraph;
should consist defining UNIX and POSIX/Threads

2nd paragrah;
consisting the history behind POSIX and why UNIX was so late to implement the support of multithreaded processes.

3rd paragraph;
should conclude it all.

I agree, but I don't think that we should limit it to specifically 'paragraphs' but rather sections. -afranco2

Here is a site that would take care of paragraph 1:
https://computing.llnl.gov/tutorials/pthreads/

GAUTHAM provided us with very useful pdf. that talks about the history of POSIX.

-[[User:Npatel1|Npatel1]]

This may be a stupid question, buy does anybody know what we have to do for citation? Are we using footnotes like a regular wiki? Or is there another conformation we need to follow? -afranco2

--footnotes are probably easiest, John v.

I'll take care of the first paragraph if you guys are comfortable with the structure of the essay (post it by the end of today). since we already have AFRANCO2 who did the history portion of the essay.

I made a new tab for "ESSAY" final copy*

-[[User:Npatel1|Npatel1]]

I'm not sure about the citations; just keep the links you used to gather the information, we'll ask him on Tuesday.
(i was just wondering, is this is the kind of structure you were looking for? or should we change the structure?)

-[[User:Npatel1|Npatel1]]

So what all do we need left? Sorry I am out of town trying to keep up as much as possible. Ive posted my research content on the primary page. And I've noticed we are getting pretty organized with our essay format. Just as an update process what has been completed and what is left to do? Because i don't wanna type up a bunch of information we may not need anymore. So Whatever else we need I can type up with all our info and then we can out the together the essay in the next couple days.

- Tmalone

And I think the structure is a good idea. We have enough information to turn it all into a good essay. If you have another suggestion on the structure though by all means tell us what you think.

- Tmalone

sounds good! I'm sorry i was unable to post the Intro today...
I'll make sure to have it by tomorrow!

Tmalone, i think we have good portion for History; i will get us started with a good intro then link in the history as our second paragraph which afranco2 has provided. then we'll talk about why UNIX was soo late; finally conclude it all with a last paragraph.

-[[User:Npatel1|Npatel1]]

Alright, I'll get started on a possible conclusion format. Then we can post it all and edit and add/delete whatever we want. So then hopefully by Tuesdays class we will have a good make-up of the essay we want.

- Tmalone

I read the current essay format posted. It was really well done good job guys. I read over it and corrected some minor grammar errors. So by sometime tomorrow I'll have a possible conclusion paragraph posted. If anyone else wants to type anything up for a conclusion they can feel free to as well! The more the better.

- Tmalone

It's looking good. Sorry if i'm a bit late to the party. I threw a paragraph down in the answer part. I know it doesn't really fit well.. but it really nees to get worked in.. -Rift

little late here too, got sidetracked with 3004 and 3008. I do have a concern in that 3 paragraphs really isn't an essay, he seemed to want more than that JOhn v.

anyone remember what was cited where in the essay? we're still missing references -- John

yeah, Tmalone decided that he was going to do the citation suitable to the essay. Feel free to help; upon finishing, we'll post it on the "page". Nothing fancy, Prof. Anil mentioned that he just wanted the basic format. John, the information that was cited is in discussion and also in collaboration. -[[User:Npatel1|Npatel1]]

== Sources ==

Everyone please post any extra links here;
we'll organize it after everyone posts their links.

posted the ones that are provided on our discussion.

-[[User:Npatel1|Npatel1]]

http://en.wikipedia.org/wiki/POSIX_Threads

http://sourceware.org/pthreads-win32/

https://computing.llnl.gov/tutorials/pthreads/

http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf

http://www.drdobbs.com/open-source/184406204;jsessionid=GKSVKT3EOMUBDQE1GHRSKHWATMY32JVN

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf

http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=6626986821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091

Journal article "Achieving Efficiency and Portability in Systems Software: A Case Study on POSIX-Compliant Multithreaded Programs" http://dx.doi.org.proxy.library.carleton.ca/10.1109/TSE.2005.98

COMP 3000 Essay 1 2010 Question 8

2010-10-14T13:17:25Z

Tmalone: /* Unsorted */

=Question=

What is the history of POSIX Threads (pthreads)? Consider - does this history explain why UNIX was so late to implement support for multithreaded processes?

=Essay=

-[[User:Npatel1|Npatel1]] ; here is the final copy guys, feel free to edit the essay under "Unsorted". if it requires major changes please post a note in discussion board, cheers.

----

'''POSIX threads, also known as Portable Operating System Interface, are high performance threads mainly distributed in UNIX but also to some Microsoft Windows OS. Threads are used in parallel programming; when a system call executes, the thread runs on an independent stream to finish its task with minimal interruptions or slowdowns. Pthreads are ideal for massive modifications to programs because the threads share one single memory space to alter a data structure, allowing constant high performance and efficiency. Pthread has become commonly used a way of adding concurrency to an application. They are widely used in UNIX; a powerful operating system written in the C language, which is continuously enhanced. Developers came across various obstacles with POSIX threads; during the beginnings of Pthreads, many technical issues had surfaced which were resolved throughout the history of POSIX threads.'''

'''The beginning of POSIX Threads starts off with hardware sellers executing their own versions of threads. These developments varied from one another, creating difficulties for programmers to implement portable thread applications. Traditionally, UNIX had a system, running only a single thread under a process. These processes could not share memory and interacted using 'pipes'. Soon after, developers created high demand for the ability to run multiple threads under one process and consequently, IEEE began to form together the POSIX standards. In 1988, POSIX.1 - created to support application portability – was ratified and accepted as the international standard in 1990. After the approval, the POSIX standard grew to more than 20 individual standards, encapsulating a large area of different groups. '''

'''POSIX.1 lays out the interfaces for OS services; their syntax, and how they should act. However, it does not define how the interface should be implemented on the OS, allowing many different operating systems to conform to standards in their own specific design and application. POSIX.2 was created for much of the same reason as POSIX.1; portable shell programming and portable program development, but describes a programmable shell and its common utilities. Although POSIX.2 improved on the original, POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto Linux; this is due to the significant differences in relationship between POSIX and UNIX.'''

'''In the last twenty years, several advancements took place; there was a huge leap from the basic performance and function of a standard thread to a multi-threading, high performance POSIX thread. However, before it was given recognition as being efficient with high performance, a POSIX thread had numerous setbacks and high-priority challenges. Although the basic principle of a POSIX thread within UNIX was already executed by hardware sellers, it was under different names with minor structural variations, prohibiting developers to create portable thread applications. Fortunately, these issues were resolved and POSIX threads were enhanced, with continuous improvements on the way. Developers made an extraordinary breakthrough in concurrent programming by enabling efficiency and high performance, especially during immense modifications to data structure. Even with a rough past, POSIX threads have improved to become one of the most widely-known and commonly used method of adding concurrency to an application.'''

----

=Unsorted=
(unsorted essay)

-[[User:Npatel1|Npatel1]] ; here is the first paragraph. you can edit/add more to the paragraph if needed!

-Afranco2; I put in the history section/strung in tmalone's stuff as well. Again, feel free to edit/add content

-Tmalone; Edited and corrected the information thus far. I will post a conclusion sometime tomorrow.

-[[User:Npatel1|Npatel1]] ; Trevor, last lines should get us started on the conclusion. Afranco2; i went to class today and prof. was talking about plagiarism, can you please check your paragraph and see if there is any signs of plagiarism. since i don't know where you gathered your information from. upon you completion please post on wiki; need to make some modification to the body paragraph.

-http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=6626986821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091 That is one of the sources which I used for my information. I don't believe that I am plagiarizing, but I know that it is easy to do accidentally. If somebody wants to check it over for me to make sure, that would be great. My information comes from the first and second page. I also used POSIX Threads and the Linux Kernel and a little bit from IEEE POSIX Testing Policy General Information

-[[User:Npatel1|Npatel1]] ; oh i just wanted to make sure since the prof. emphasized on it a lot last class! thanks Afranco2.

POSIX (Portable Operating System Interface) threads, are high performance threads mainly distributed in UNIX but also to some Microsoft Windows OSes. Threads are used in parallel programming; when a system call executes, the thread runs on an independent stream to finish its task with minimal interruptions or slowdowns. Pthreads (from POSIX threads) are ideal for massive modifications to programs because the threads share one single memory space to alter a data structure, allowing constant high performance and efficiency. Pthreads have become a commonly used way of adding concurrency to an application. They are widely used in UNIX; a powerful operating system written in the C language, which is continuously enhanced. Developers came across various obstacles with POSIX threads; during the beginnings of Pthreads, many technical issues had surfaced which were resolved throughout the history of POSIX threads.

The history of POSIX Threads is that many hardware sellers executed their own versions of threads. These developments differed from one another, creating difficulties for programmers to implement portable thread applications. UNIX traditionally had a system running only a single thread under a process. These processes could not share memory and interacted using 'pipes'. Once developers started wanting to be able to run multiple threads under one process, IEEE began to form together the POSIX standards. In 1988 POSIX.1 (created to support application portability) was ratified and was accepted as the international standard in 1990. From there the POSIX standards grew to more than 20 individual standards, encapsulating a large area of different groups.

POSIX.1 lays out the interfaces for OS services; their syntax, and how they should act. It however does not define how the interface should be implemented on the OS. This is made to allow many different operating systems to conform to standards in their own specific design and application. POSIX.2 was created for much the same reason as POSIX.1 (portable shell programming, portable program development) but describes a programmable shell and its common utilities.

POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto Linux; this is due to the significant differences in relationship between POSIX and UNIX.

^^^ this statement sounds a bit off. why does UNIX care what Linux can handle? - John v.

I'll look into that tomorrow; working on 3005 Assignment. John, if you have a suggestion or an add-on that you wish to provide, please do so under collaboration.

-[[User:Npatel1|Npatel1]]

Hey guys, before end of tomorrow if there is anything missing or if anyone wishes to contribute more towards the essay please do so asap.

-[[User:Npatel1|Npatel1]]

UNIX cares about what Linux can handle because POSIX threads are mainly used in Linux systems. It is a very big deal if a certain type of thread is generating countless errors on the main system type the thread is created for. And regardless of just the fact that its widely used on Linux, UNIX would care because compatibility is one of the most important things to have. For a POSIX thread to not be compatible with Linux just because UNIX didn't care, then the progress of multi-threading and POSIX threads would not be able to be used in Linux. Then Linux would not be as widely used as it would not be enhanced like other systems. It is important for systems to have that compatibility, so that they don't end up left in the dust of technology.

-[[User:Tmalone|Tmalone]]

=Collaboration=

Hey guys, i'm just gunna get this started by posting a few links for everyone to get going. This will help explain a general idea of what they are and the history of them. Please add some more links or anything else you think would be helpful!

http://en.wikipedia.org/wiki/POSIX_Threads
https://computing.llnl.gov/tutorials/pthreads/
http://sourceware.org/pthreads-win32/

-[[User:tmalone|tmalone]]

I found this, might not help, but it might:--[[User:Rannath|Rannath]] 02:09, 6 October 2010 (UTC)

I'm not sure about the rest of you, but most of what I am able to find has to do with information on things that fall under POSIX, not actually about POSIX-afranco2

POSIX Threads, or pthreads, is a thread that is commonly used in UNIX systems but it also seen in some Microsoft Windows systems. A thread is a unit of process that executes segments of code within applications. When a process gets called from the system, the thread will execute the code for the process. POSIX stands for Portable Operating System Interface (for UNIX) and has been used by many independent sellers of hardware. There has always been issues such that developers could not create a reliable protable pthread application. For the use of multi-threading, its implementation arrived fairly late because the systems could not support it. Data mapping onto Linux gave birth to several problems due to the fact that POSIX and UNIX were implemented so differently.

-[[User:tmalone|tmalone]]

http://www.faqs.org/faqs/os-research/part1/section-10.html

Might be of some use as well --[[User:Lmundt|Lmundt]] 14:48, 7 October 2010 (UTC)
https://computing.llnl.gov/tutorials/pthreads/

Edited version from what -tmalone has written.

POSIX Threads is also called pthreads. Portable Operating System interface; mainly for Unix but it’s also distributed to some Microsoft Windows OS. A Thread is a unit of process that resides inside a process and executes when a system call has been executed. Threads have same global and all the threads share memory, threads also contain their personal private data. Pthread has become commonly used a way of adding concurrency to an application. The history of POSIX Threads is that many hardware sellers executed their own versions of threads. These developments differed from one another, creating difficulties for programmers to implement portable thread applications. POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto linux; this is due to the significant differences in relationship between POSIX and UNIX.

-Npatel1

A bit different of a explanation of the history of threads in Unix:

Originally in UNIX things similar to threads existed, they were however, called processes. The “processes” shared memory and used semaphores and thus “threads” have been around from the start. However, they disappeared when UNIX took the multics definition of process to mean they should not share memory, and all of sudden the ability to have threads disappeared. As people clamored to have the good old processes back, they created a new thing called “threads” that was actually what they had previously. So while it seemed they were late to support multithreaded processes, in reality they merely had a brief period where they didn’t have multi-threadedness.

-[[User:Rift|Rift]] 23:42, 10 October 2010 (UTC)

Here is a possible simple conclusion I've typed up. I used the first chunk of Rifts paragraph then just threw in some extra info. Go easy on me lol

Originally in UNIX things similar to threads existed, they were however, called processes. The “processes” shared memory and used semaphores and thus “threads” have been around from the start. However, they disappeared when UNIX took the multics definition of process to mean they should not share memory, and all of sudden the ability to have threads disappeared. What are now considered POSIX threads have just been aliased for many years. The late implementation of these threads was because of the fact that so many developers had the basic principle of a POSIX thread in use, it was simply under a different name with minor structural differences. It is quite evident how POSIX threads came to be over the years especially within the UNIX system. From the basic performance and function of a standard thread to the multi-threading abilities of the POSIX thread, the development became more and more concrete. Though problems arose, such as creating portable thread applications between developers, solutions were found. POSIX.1 and POSIX.2 were created to display interfaces with specific syntax and to describe programming shells for many operating systems. Given the last 20 years when the leap was taken between a standard thread and a POSIX thread, and the speed in which the POSIX thread has been implemented, it can be said that given another 20 years the POSIX thread will have turned into something even more worth the wait.

Okay guys this is a conclusion I've typed up. I have absolutely no idea if this is good enough, I find it pretty tough to write conclusions. Nonetheless, feel free to make changes and add/delete whatever you want. I'm not sure how formal he wants it to be, but I hope this is at least decent. If you want me to make some changes let me know what to change and I'll do it asap.

(I constantly make changes myself :p)

- Tmalone

COMP 3000 Essay 1 2010 Question 8

2010-10-12T17:55:09Z

Tmalone: /* Answer */

=Question=

What is the history of POSIX Threads (pthreads)? Consider - does this history explain why UNIX was so late to implement support for multithreaded processes?

=Essay=
(Final Copy goes here)

-Npatel1; here is the first paragraph. you can edit/add more to the paragraph if needed!

-Afranco2; I put in the history section/strung in tmalone's stuff as well. Again, feel free to edit/add content

-Tmalone; Edited and corrected the information thus far. I will post a conclusion sometime tomorrow.

-Npatel1; Trevor, last lines should get us started on the conclusion. Afranco2; i went to class today and prof. was talking about plagiarism, can you please check your paragraph and see if there is any signs of plagiarism. since i don't know where you gathered your information from. upon you completion please post on wiki; need to make some modification to the body paragraph.

-http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=6626986821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091 That is one of the sources which I used for my information. I don't believe that I am plagiarizing, but I know that it is easy to do accidentally. If somebody wants to check it over for me to make sure, that would be great. My information comes from the first and second page. I also used POSIX Threads and the Linux Kernel and a little bit from IEEE POSIX Testing Policy General Information

'''POSIX threads, also known as Portable Operating System Interface, are high performance threads mainly distributed in UNIX but also to some Microsoft Windows OS. Threads are used in parallel programming; when a system call executes, the thread runs on an independent stream to finish its task with minimal interruptions or slowdowns. Pthreads are ideal for massive modifications to programs because the threads share one single memory space to alter a data structure, allowing constant high performance and efficiency. Pthread has become commonly used a way of adding concurrency to an application. They are widely used in UNIX; a powerful operating system written in the C language, which is continuously enhanced. Developers came across various obstacles with POSIX threads; during the beginnings of Pthreads, many technical issues had surfaced which were resolved throughout the history of POSIX threads.'''

'''The history of POSIX Threads is that many hardware sellers executed their own versions of threads. These developments differed from one another, creating difficulties for programmers to implement portable thread applications. UNIX traditionally had a system running only a single thread under a process. These processes could not share memory and interacted using 'pipes'. Once developers started wanting to be able to run multiple threads under one process, IEEE began to form together the POSIX standards. In 1988 POSIX.1 (created to support application portability) was ratified and was accepted as the international standard in 1990. From there the POSIX standards grew to more than 20 individual standards, encapsulating a large area of different groups.'''

'''POSIX.1 lays out the interfaces for OS services; thier syntax, and how they should act. It however does not define how the interface should be implemented on the OS. This is made to allow many different operating systems to conform to standards in thier own specific design and application. POSIX.2 was created for much the same reason as POSIX.1 (portable shell programming, portable program development) but describes a programmable shell and its common utilities.'''

'''POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto Linux; this is due to the significant differences in relationship between POSIX and UNIX.'''

=Answer=

Hey guys, i'm just gunna get this started by posting a few links for everyone to get going. This will help explain a general idea of what they are and the history of them. Please add some more links or anything else you think would be helpful!

http://en.wikipedia.org/wiki/POSIX_Threads
https://computing.llnl.gov/tutorials/pthreads/
http://sourceware.org/pthreads-win32/

-[[User:tmalone|tmalone]]

I found this, might not help, but it might:--[[User:Rannath|Rannath]] 02:09, 6 October 2010 (UTC)

I'm not sure about the rest of you, but most of what I am able to find has to do with information on things that fall under POSIX, not actually about POSIX-afranco2

POSIX Threads, or pthreads, is a thread that is commonly used in UNIX systems but it also seen in some Microsoft Windows systems. A thread is a unit of process that executes segments of code within applications. When a process gets called from the system, the thread will execute the code for the process. POSIX stands for Portable Operating System Interface (for UNIX) and has been used by many independent sellers of hardware. There has always been issues such that developers could not create a reliable protable pthread application. For the use of multi-threading, its implementation arrived fairly late because the systems could not support it. Data mapping onto Linux gave birth to several problems due to the fact that POSIX and UNIX were implemented so differently.

-[[User:tmalone|tmalone]]

http://www.faqs.org/faqs/os-research/part1/section-10.html

Might be of some use as well --[[User:Lmundt|Lmundt]] 14:48, 7 October 2010 (UTC)
https://computing.llnl.gov/tutorials/pthreads/

Edited version from what -tmalone has written.

POSIX Threads is also called pthreads. Portable Operating System interface; mainly for Unix but it’s also distributed to some Microsoft Windows OS. A Thread is a unit of process that resides inside a process and executes when a system call has been executed. Threads have same global and all the threads share memory, threads also contain their personal private data. Pthread has become commonly used a way of adding concurrency to an application. The history of POSIX Threads is that many hardware sellers executed their own versions of threads. These developments differed from one another, creating difficulties for programmers to implement portable thread applications. POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto linux; this is due to the significant differences in relationship between POSIX and UNIX.

-Npatel1

A bit different of a explanation of the history of threads in Unix:

Originally in UNIX things similar to threads existed, they were however, called processes. The “processes” shared memory and used semaphores and thus “threads” have been around from the start. However, they disappeared when UNIX took the multics definition of process to mean they should not share memory, and all of sudden the ability to have threads disappeared. As people clamored to have the good old processes back, they created a new thing called “threads” that was actually what they had previously. So while it seemed they were late to support multithreaded processes, in reality they merely had a brief period where they didn’t have multi-threadedness.

-[[User:Rift|Rift]] 23:42, 10 October 2010 (UTC)

Here is a possible simple conclusion I've typed up. I used the first chunk of Rifts paragraph then just threw in some extra info. Go easy on me lol

Originally in UNIX things similar to threads existed, they were however, called processes. The “processes” shared memory and used semaphores and thus “threads” have been around from the start. However, they disappeared when UNIX took the multics definition of process to mean they should not share memory, and all of sudden the ability to have threads disappeared. What are now considered POSIX threads have just been aliased for many years. The late implementation of these threads was because of the fact that so many developers had the basic principle of a POSIX thread in use, it was simply under a different name with minor structural differences. It is quite evident how POSIX threads came to be over the years especially within the UNIX system. From the basic performance and function of a standard thread to the multi-threading abilities of the POSIX thread, the development became more and more concrete. Though problems arose, such as creating portable thread applications between developers, solutions were found. POSIX.1 and POSIX.2 were created to display interfaces with specific syntax and to describe programming shells for many operating systems. Given the last 20 years when the leap was taken between a standard thread and a POSIX thread, and the speed in which the POSIX thread has been implemented, it can be said that given another 20 years the POSIX thread will have turned into something even more worth the wait.

Okay guys this is a conclusion I've typed up. I have absolutely no idea if this is good enough, I find it pretty tough to write conclusions. Nonetheless, feel free to make changes and add/delete whatever you want. I'm not sure how formal he wants it to be, but I hope this is at least decent. If you want me to make some changes let me know what to change and I'll do it asap.

(I constantly make changes myself :p)

- Tmalone

COMP 3000 Essay 1 2010 Question 8

2010-10-12T17:48:12Z

Tmalone: /* Answer */

=Question=

What is the history of POSIX Threads (pthreads)? Consider - does this history explain why UNIX was so late to implement support for multithreaded processes?

=Essay=
(Final Copy goes here)

-Npatel1; here is the first paragraph. you can edit/add more to the paragraph if needed!

-Afranco2; I put in the history section/strung in tmalone's stuff as well. Again, feel free to edit/add content

-Tmalone; Edited and corrected the information thus far. I will post a conclusion sometime tomorrow.

-Npatel1; Trevor, last lines should get us started on the conclusion. Afranco2; i went to class today and prof. was talking about plagiarism, can you please check your paragraph and see if there is any signs of plagiarism. since i don't know where you gathered your information from. upon you completion please post on wiki; need to make some modification to the body paragraph.

-http://delivery.acm.org/10.1145/220000/210315/p11-walli.pdf?key1=210315&key2=6626986821&coll=GUIDE&dl=GUIDE&CFID=108396689&CFTOKEN=35895091 That is one of the sources which I used for my information. I don't believe that I am plagiarizing, but I know that it is easy to do accidentally. If somebody wants to check it over for me to make sure, that would be great. My information comes from the first and second page. I also used POSIX Threads and the Linux Kernel and a little bit from IEEE POSIX Testing Policy General Information

'''POSIX threads, also known as Portable Operating System Interface, are high performance threads mainly distributed in UNIX but also to some Microsoft Windows OS. Threads are used in parallel programming; when a system call executes, the thread runs on an independent stream to finish its task with minimal interruptions or slowdowns. Pthreads are ideal for massive modifications to programs because the threads share one single memory space to alter a data structure, allowing constant high performance and efficiency. Pthread has become commonly used a way of adding concurrency to an application. They are widely used in UNIX; a powerful operating system written in the C language, which is continuously enhanced. Developers came across various obstacles with POSIX threads; during the beginnings of Pthreads, many technical issues had surfaced which were resolved throughout the history of POSIX threads.'''

'''The history of POSIX Threads is that many hardware sellers executed their own versions of threads. These developments differed from one another, creating difficulties for programmers to implement portable thread applications. UNIX traditionally had a system running only a single thread under a process. These processes could not share memory and interacted using 'pipes'. Once developers started wanting to be able to run multiple threads under one process, IEEE began to form together the POSIX standards. In 1988 POSIX.1 (created to support application portability) was ratified and was accepted as the international standard in 1990. From there the POSIX standards grew to more than 20 individual standards, encapsulating a large area of different groups.'''

'''POSIX.1 lays out the interfaces for OS services; thier syntax, and how they should act. It however does not define how the interface should be implemented on the OS. This is made to allow many different operating systems to conform to standards in thier own specific design and application. POSIX.2 was created for much the same reason as POSIX.1 (portable shell programming, portable program development) but describes a programmable shell and its common utilities.'''

'''POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto Linux; this is due to the significant differences in relationship between POSIX and UNIX.'''

=Answer=

Hey guys, i'm just gunna get this started by posting a few links for everyone to get going. This will help explain a general idea of what they are and the history of them. Please add some more links or anything else you think would be helpful!

http://en.wikipedia.org/wiki/POSIX_Threads
https://computing.llnl.gov/tutorials/pthreads/
http://sourceware.org/pthreads-win32/

-[[User:tmalone|tmalone]]

I found this, might not help, but it might:--[[User:Rannath|Rannath]] 02:09, 6 October 2010 (UTC)

I'm not sure about the rest of you, but most of what I am able to find has to do with information on things that fall under POSIX, not actually about POSIX-afranco2

POSIX Threads, or pthreads, is a thread that is commonly used in UNIX systems but it also seen in some Microsoft Windows systems. A thread is a unit of process that executes segments of code within applications. When a process gets called from the system, the thread will execute the code for the process. POSIX stands for Portable Operating System Interface (for UNIX) and has been used by many independent sellers of hardware. There has always been issues such that developers could not create a reliable protable pthread application. For the use of multi-threading, its implementation arrived fairly late because the systems could not support it. Data mapping onto Linux gave birth to several problems due to the fact that POSIX and UNIX were implemented so differently.

-[[User:tmalone|tmalone]]

http://www.faqs.org/faqs/os-research/part1/section-10.html

Might be of some use as well --[[User:Lmundt|Lmundt]] 14:48, 7 October 2010 (UTC)
https://computing.llnl.gov/tutorials/pthreads/

Edited version from what -tmalone has written.

POSIX Threads is also called pthreads. Portable Operating System interface; mainly for Unix but it’s also distributed to some Microsoft Windows OS. A Thread is a unit of process that resides inside a process and executes when a system call has been executed. Threads have same global and all the threads share memory, threads also contain their personal private data. Pthread has become commonly used a way of adding concurrency to an application. The history of POSIX Threads is that many hardware sellers executed their own versions of threads. These developments differed from one another, creating difficulties for programmers to implement portable thread applications. POSIX threading has always been an issue on Linux. UNIX was so late to implement support for multithreaded process because it does not map that well onto linux; this is due to the significant differences in relationship between POSIX and UNIX.

-Npatel1

A bit different of a explanation of the history of threads in Unix:

Originally in UNIX things similar to threads existed, they were however, called processes. The “processes” shared memory and used semaphores and thus “threads” have been around from the start. However, they disappeared when UNIX took the multics definition of process to mean they should not share memory, and all of sudden the ability to have threads disappeared. As people clamored to have the good old processes back, they created a new thing called “threads” that was actually what they had previously. So while it seemed they were late to support multithreaded processes, in reality they merely had a brief period where they didn’t have multi-threadedness.

-[[User:Rift|Rift]] 23:42, 10 October 2010 (UTC)

Here is a possible simple conclusion I've typed up. Go easy on me lol

What are now considered POSIX threads have been aliased for many years. The late implementation of these threads was because of the fact that so many developers had the basic principle of a POSIX thread in use, it was simply under a different name with minor structural differences. It is quite evident how POSIX threads came to be over the years especially within the UNIX system. From the basic performance and function of a standard thread to the multi-threading abilities of the POSIX thread, the development became more and more concrete. Though problems arose, such as creating portable thread applications between developers, solutions were found. POSIX.1 and POSIX.2 were created to display interfaces with specific syntax and to describe programming shells for many operating systems. Given the last 20 years when the leap was taken between a standard thread and a POSIX thread, and the speed in which the POSIX thread has been implemented, it can be said that given another 20 years the POSIX thread will have turned into something even more worth the wait.

Okay guys this is a conclusion I've typed up. I have absolutely no idea if this is good enough, I find it pretty tough to write conclusions. Nonetheless, feel free to make changes and add/delete whatever you want. I'm not sure how formal he wants it to be, but I hope this is at least decent. If you want me to make some changes let me know what to change and I'll do it asap.

- Tmalone

COMP 3000 Essay 1 2010 Question 8

2010-10-10T19:07:25Z

Tmalone: /* Essay */

Talk:COMP 3000 Essay 1 2010 Question 8

2010-10-10T19:05:53Z

Tmalone: /* Discussion */

== Group 8 ==

'''GROUP NAMES:'''

Niravkumar Patel (Npatel1)

Trevor Malone (Tmalone)

== Discussion ==

[http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf POSIX Threads and the Linux Kernel] --[[User:Gautam|Gautam]] 23:52, 5 October 2010 (UTC)

Not from your group. However I found a webpage which you might find useful.
[http://www.drdobbs.com/open-source/184406204;jsessionid=3MRSO5YMO1QVRQE1GHRSKHWATMY32JVN The New Implementation of Threads for Linux]
--[[User:Gautam|Gautam]] 22:56, 5 October 2010 (UTC)

Not extremely helpful but: [http://www.unix.com/unix-dummies-questions-answers/7-short-history-unix-l-madden-ic-ac-uk.html A short history of unix] [[User:Rift|Rift]] 18:30, 7 October 2010 (UTC)

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf IEEE POSIX Testing Policy General Information
The POSIX family of standards, Stephen R. Walli
-afranco2

I'm not sure how we are planning on structuring this essay, but I will just write a bit on the history of Posix part for now. Does somebody want to handle writing an intro? - afranco2

Hey guys, sorry for the late reply...
i just wanted everyone to finish their assignment portion. we would have our own set of explanation for question 8.

AFRANCO2; Here is a suggestion.

1st paragraph;
should consist defining UNIX and POSIX/Threads

2nd paragrah;
consisting the history behind POSIX and why UNIX was so late to implement the support of multithreaded processes.

3rd paragraph;
should conclude it all.

I agree, but I don't think that we should limit it to specifically 'paragraphs' but rather sections. -afranco2

Here is a site that would take care of paragraph 1:
https://computing.llnl.gov/tutorials/pthreads/

GAUTHAM provided us with very useful pdf. that talks about the history of POSIX.
- Npatel1

This may be a stupid question, buy does anybody know what we have to do for citation? Are we using footnotes like a regular wiki? Or is there another conformation we need to follow? -afranco2

I'll take care of the first paragraph if you guys are comfortable with the structure of the essay (post it by the end of today). since we already have AFRANCO2 who did the history portion of the essay.

I made a new tab for "ESSAY" final copy*

- Npatel1

I'm not sure about the citations; just keep the links you used to gather the information, we'll ask him on Tuesday.
(i was just wondering, is this is the kind of structure you were looking for? or should we change the structure?)

-Npatel1

So what all do we need left? Sorry I am out of town trying to keep up as much as possible. Ive posted my research content on the primary page. And I've noticed we are getting pretty organized with our essay format. Just as an update process what has been completed and what is left to do? Because i don't wanna type up a bunch of information we may not need anymore. So Whatever else we need I can type up with all our info and then we can out the together the essay in the next couple days.

- Tmalone

And I think the structure is a good idea. We have enough information to turn it all into a good essay. If you have another suggestion on the structure though by all means tell us what you think.

- Tmalone

sounds good! I'm sorry i was unable to post the Intro today...
I'll make sure to have it by tomorrow!

Tmalone, i think we have good portion for History; i will get us started with a good intro then link in the history as our second paragraph which afranco2 has provided. then we'll talk about why UNIX was soo late; finally conclude it all with a last paragraph.

-Npatel1

Alright, I'll get started on a possible conclusion format. Then we can post it all and edit and add/delete whatever we want. So then hopefully by Tuesdays class we will have a good make-up of the essay we want.

- Tmalone

I read the current essay format posted. It was really well done good job guys. I read over it and corrected some minor grammar errors. So by sometime tomorrow I'll have a possible conclusion paragraph posted. If anyone else wants to type anything up for a conclusion they can feel free to as well! The more the better.

- Tmalone

== Sources ==

COMP 3000 Essay 1 2010 Question 8

2010-10-10T19:03:43Z

Tmalone: /* Essay */

Talk:COMP 3000 Essay 1 2010 Question 8

2010-10-10T15:32:26Z

Tmalone: /* Sources */

== Sources ==

[http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf POSIX Threads and the Linux Kernel] --[[User:Gautam|Gautam]] 23:52, 5 October 2010 (UTC)

Not from your group. However I found a webpage which you might find useful.
[http://www.drdobbs.com/open-source/184406204;jsessionid=3MRSO5YMO1QVRQE1GHRSKHWATMY32JVN The New Implementation of Threads for Linux]
--[[User:Gautam|Gautam]] 22:56, 5 October 2010 (UTC)

Not extremely helpful but: [http://www.unix.com/unix-dummies-questions-answers/7-short-history-unix-l-madden-ic-ac-uk.html A short history of unix] [[User:Rift|Rift]] 18:30, 7 October 2010 (UTC)

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf IEEE POSIX Testing Policy General Information
The POSIX family of standards, Stephen R. Walli
-afranco2

I'm not sure how we are planning on structuring this essay, but I will just write a bit on the history of Posix part for now. Does somebody want to handle writing an intro? - afranco2

Hey guys, sorry for the late reply...
i just wanted everyone to finish their assignment portion. we would have our own set of explanation for question 8.

AFRANCO2; Here is a suggestion.

1st paragraph;
should consist defining UNIX and POSIX/Threads

2nd paragrah;
consisting the history behind POSIX and why UNIX was so late to implement the support of multithreaded processes.

3rd paragraph;
should conclude it all.

I agree, but I don't think that we should limit it to specifically 'paragraphs' but rather sections. -afranco2

Here is a site that would take care of paragraph 1:
https://computing.llnl.gov/tutorials/pthreads/

GAUTHAM provided us with very useful pdf. that talks about the history of POSIX.
- Npatel1

This may be a stupid question, buy does anybody know what we have to do for citation? Are we using footnotes like a regular wiki? Or is there another conformation we need to follow? -afranco2

I'll take care of the first paragraph if you guys are comfortable with the structure of the essay (post it by the end of today). since we already have AFRANCO2 who did the history portion of the essay.

I made a new tab for "ESSAY" final copy*

- Npatel1

I'm not sure about the citations; just keep the links you used to gather the information, we'll ask him on Tuesday.
(i was just wondering, is this is the kind of structure you were looking for? or should we change the structure?)

-Npatel1

So what all do we need left? Sorry I am out of town trying to keep up as much as possible. Ive posted my research content on the primary page. And I've noticed we are getting pretty organized with our essay format. Just as an update process what has been completed and what is left to do? Because i don't wanna type up a bunch of information we may not need anymore. So Whatever else we need I can type up with all our info and then we can out the together the essay in the next couple days.

- Tmalone

And I think the structure is a good idea. We have enough information to turn it all into a good essay. If you have another suggestion on the structure though by all means tell us what you think.

- Tmalone

sounds good! I'm sorry i was unable to post the Intro today...
I'll make sure to have it by tomorrow!

Tmalone, i think we have good portion for History; i will get us started with a good intro then link in the history as our second paragraph which afranco2 has provided. then we'll talk about why UNIX was soo late; finally conclude it all with a last paragraph.

-Npatel1

Alright, I'll get started on a possible conclusion format. Then we can post it all and edit and add/delete whatever we want. So then hopefully by Tuesdays class we will have a good make-up of the essay we want.

- Tmalone

Talk:COMP 3000 Essay 1 2010 Question 8

2010-10-10T15:30:56Z

Tmalone: /* Sources */

Talk:COMP 3000 Essay 1 2010 Question 8

2010-10-10T00:13:27Z

Tmalone: /* Sources */

== Sources ==

[http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf POSIX Threads and the Linux Kernel] --[[User:Gautam|Gautam]] 23:52, 5 October 2010 (UTC)

Not from your group. However I found a webpage which you might find useful.
[http://www.drdobbs.com/open-source/184406204;jsessionid=3MRSO5YMO1QVRQE1GHRSKHWATMY32JVN The New Implementation of Threads for Linux]
--[[User:Gautam|Gautam]] 22:56, 5 October 2010 (UTC)

Not extremely helpful but: [http://www.unix.com/unix-dummies-questions-answers/7-short-history-unix-l-madden-ic-ac-uk.html A short history of unix] [[User:Rift|Rift]] 18:30, 7 October 2010 (UTC)

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf IEEE POSIX Testing Policy General Information
The POSIX family of standards, Stephen R. Walli
-afranco2

I'm not sure how we are planning on structuring this essay, but I will just write a bit on the history of Posix part for now. Does somebody want to handle writing an intro? - afranco2

Hey guys, sorry for the late reply...
i just wanted everyone to finish their assignment portion. we would have our own set of explanation for question 8.

AFRANCO2; you mentioned that how are we taking care of the structure of the essay?

here is a suggestion:

1st paragraph;
should consist defining UNIX and POSIX/Threads

2nd paragrah;
consisting the history behind POSIX and why UNIX was so late to implement the support of multithreaded processes.

3rd paragraph;
should conclude it all.

I agree, but I don't think that we should limit it to specifically 'paragraphs' but rather sections. -afranco2

Here is a site that would take care of paragraph 1:
https://computing.llnl.gov/tutorials/pthreads/

GAUTHAM provided us with very useful pdf. that talks about the history of POSIX.
- Npatel1

This may be a stupid question, buy does anybody know what we have to do for citation? Are we using footnotes like a regular wiki? Or is there another conformation we need to follow? -afranco2

I'll take care of the first paragraph if you guys are comfortable with the structure of the essay (post it by the end of today). since we already have AFRANCO2 who did the history portion of the essay.

I made a new tab for "ESSAY" final copy*

- Npatel1

I'm not sure about the citations; just keep the links you used to gather the information, we'll ask him on Tuesday.
(i was just wondering, is this is the kind of structure you were looking for? or should we change the structure?)

-Npatel1

So what all do we need left? Sorry I am out of town trying to keep up as much as possible. Ive posted my research content on the primary page. And I've noticed we are getting pretty organized with our essay format. Just as an update process what has been completed and what is left to do? Because i don't wanna type up a bunch of information we may not need anymore. So Whatever else we need I can type up with all our info and then we can out the together the essay in the next couple days.

- Tmalone

And I think the structure is a good idea. We have enough information to turn it all into a good essay. If you have another suggestion on the structure though by all means tell us what you think.

Talk:COMP 3000 Essay 1 2010 Question 8

2010-10-10T00:09:40Z

Tmalone: /* Sources */

== Sources ==

[http://www.kernel.org/doc/ols/2002/ols2002-pages-330-337.pdf POSIX Threads and the Linux Kernel] --[[User:Gautam|Gautam]] 23:52, 5 October 2010 (UTC)

Not from your group. However I found a webpage which you might find useful.
[http://www.drdobbs.com/open-source/184406204;jsessionid=3MRSO5YMO1QVRQE1GHRSKHWATMY32JVN The New Implementation of Threads for Linux]
--[[User:Gautam|Gautam]] 22:56, 5 October 2010 (UTC)

Not extremely helpful but: [http://www.unix.com/unix-dummies-questions-answers/7-short-history-unix-l-madden-ic-ac-uk.html A short history of unix] [[User:Rift|Rift]] 18:30, 7 October 2010 (UTC)

http://standards.ieee.org/regauth/posix/POSIX-A.FM5.pdf IEEE POSIX Testing Policy General Information
The POSIX family of standards, Stephen R. Walli
-afranco2

I'm not sure how we are planning on structuring this essay, but I will just write a bit on the history of Posix part for now. Does somebody want to handle writing an intro? - afranco2

Hey guys, sorry for the late reply...
i just wanted everyone to finish their assignment portion. we would have our own set of explanation for question 8.

AFRANCO2; you mentioned that how are we taking care of the structure of the essay?

here is a suggestion:

1st paragraph;
should consist defining UNIX and POSIX/Threads

2nd paragrah;
consisting the history behind POSIX and why UNIX was so late to implement the support of multithreaded processes.

3rd paragraph;
should conclude it all.

I agree, but I don't think that we should limit it to specifically 'paragraphs' but rather sections. -afranco2

Here is a site that would take care of paragraph 1:
https://computing.llnl.gov/tutorials/pthreads/

GAUTHAM provided us with very useful pdf. that talks about the history of POSIX.
- Npatel1

This may be a stupid question, buy does anybody know what we have to do for citation? Are we using footnotes like a regular wiki? Or is there another conformation we need to follow? -afranco2

I'll take care of the first paragraph if you guys are comfortable with the structure of the essay (post it by the end of today). since we already have AFRANCO2 who did the history portion of the essay.

I made a new tab for "ESSAY" final copy*

- Npatel1

I'm not sure about the citations; just keep the links you used to gather the information, we'll ask him on Tuesday.
(i was just wondering, is this is the kind of structure you were looking for? or should we change the structure?)

-Npatel1

So what all do we need left? Sorry I am out of town trying to keep up as much as possible. Ive posted my research content on the primary page. And I've noticed we are getting pretty organized with our essay format. Just as an update process what has been completed and what is left to do? Because i don't wanna type up a bunch of information we may not need anymore. So Whatever else we need I can type up with all our info and then we can out the together the essay in the next couple days.

- Tmalone

COMP 3000 Essay 1 2010 Question 8

2010-10-09T03:53:45Z

Tmalone: /* Answer */

=Question=

What is the history of POSIX Threads (pthreads)? Consider - does this history explain why UNIX was so late to implement support for multithreaded processes?

=Answer=

Posix threads began in an era when multithreading started becoming a popular idea. UNIX traditionally had a system running only a single thread under a process. These processes could not share memory and interacted using 'pipes'. Once developers started wanting to be able to run multiple threads under one process, IEEE began to form together the POSIX standards. In 1988 POSIX.1 was ratified and was accepted as the international standard in 1990. From there the POSIX standards grew to more than 20 individual standards, encapsulating a large area of different groups.-afranco2

Hey guys, i'm just gunna get this started by posting a few links for everyone to get going. This will help explain a general idea of what they are and the history of them. Please add some more links or anything else you think would be helpful!

http://en.wikipedia.org/wiki/POSIX_Threads
https://computing.llnl.gov/tutorials/pthreads/
http://sourceware.org/pthreads-win32/

-[[User:tmalone|tmalone]]

I found this, might not help, but it might:--[[User:Rannath|Rannath]] 02:09, 6 October 2010 (UTC)

I'm not sure about the rest of you, but most of what I am able to find has to do with information on things that fall under POSIX, not actually about POSIX-afranco2

POSIX Threads, or pthreads, is a thread that is commonly used in UNIX systems but it also seen in some Microsoft Windows systems. A thread is a unit of process that executes segments of code within applications. When a process gets called from the system, the thread will execute the code for the process. POSIX stands for Portable Operating System Interface (for UNIX) and has been used by many independent sellers of hardware. There has always been issues such that developers could not create a reliable protable pthread application. For the use of multi-threading, its implementation arrived fairly late because the systems could not support it. Data mapping onto Linux gave birth to several problems due to the fact that POSIX and UNIX were implemented so differently.

-[[User:tmalone|tmalone]]

http://www.faqs.org/faqs/os-research/part1/section-10.html

Might be of some use as well --[[User:Lmundt|Lmundt]] 14:48, 7 October 2010 (UTC)
https://computing.llnl.gov/tutorials/pthreads/

COMP 3000 Essay 1 2010 Question 8

2010-10-06T13:18:06Z

Tmalone: /* Answer */

=Question=

What is the history of POSIX Threads (pthreads)? Consider - does this history explain why UNIX was so late to implement support for multithreaded processes?

=Answer=
Hey guys, i'm just gunna get this started by posting a few links for everyone to get going. This will help explain a general idea of what they are and the history of them. Please add some more links or anything else you think would be helpful!

http://en.wikipedia.org/wiki/POSIX_Threads
https://computing.llnl.gov/tutorials/pthreads/
http://sourceware.org/pthreads-win32/

-[[User:tmalone|tmalone]]

I found this, might not help, but it might:--[[User:Rannath|Rannath]] 02:09, 6 October 2010 (UTC)

http://www.faqs.org/faqs/os-research/part1/section-10.html

COMP 3000 Essay 1 2010 Question 8

2010-10-06T00:32:47Z

Tmalone: /* Answer */

=Question=

What is the history of POSIX Threads (pthreads)? Consider - does this history explain why UNIX was so late to implement support for multithreaded processes?

=Answer=
Hey guys, i'm just gunna get this started by posting a few links for everyone to get going. This will help explain a general idea of what they are and the history of them. Please add some more links or anything else you think would be helpful!

http://en.wikipedia.org/wiki/POSIX_Threads
https://computing.llnl.gov/tutorials/pthreads/
http://sourceware.org/pthreads-win32/

-Trevor

COMP 3000 Essay 1 2010 Question 8

2010-10-06T00:30:49Z

Tmalone: /* Answer */

=Question=

What is the history of POSIX Threads (pthreads)? Consider - does this history explain why UNIX was so late to implement support for multithreaded processes?

=Answer=
Hey guys, i'm just gunna get this started by posting a few links for everyone to get going. This will help explain a general idea of what they are and the history of them. Please add some more links or anything else you think would be helpful!

http://en.wikipedia.org/wiki/POSIX_Threads
https://computing.llnl.gov/tutorials/pthreads/
http://sourceware.org/pthreads-win32/