CoreLinux++
|
Goals
|
|
Developer's Corner
|
|
Contacts
|
|
|
Thread Use Case Report
Thread Use Case Report
Generated at: Sun, Mar 19, 2000
08:37:30
TABLE OF CONTENTS
- REPORT BODY
- Use case report
- Class report
- Data package
- Component View package
- Analysis package
- UnitOfExecution class
- ThreadIdentifier class
- OperatingSystem class
- Stack class
- [Unnamed] class
- Resources class
- Signals class
- Memory class
- [Unnamed] class
- State class
- libcorelinux package
- Use Cases package
- Participants package
- Developer class
- Implementor class
- Model dictionary
- SUMMARY
REPORT BODY
Use case report
use case Start a thread
- Documentation:
Start an asynchronous path of execution.
use case Wait for thread
- Documentation:
Wait for the execution of one or more threads to complete.
use case Stop a thread
- Documentation:
Stop a thread from continuing execution.
use case Configure a thread
- Documentation:
Setup the profile or characteristics of a thread prior to its execution.
use case Retrieve thread information
- Documentation:
Retrieve information about a thread, prior, during, or after its execution.
- actor Developer
- Documentation:
Developer
- actor Implementor
- Superclasses:
- Data::Use Cases::Participants::Developer
- Documentation:
Implementor is a developer that uses either the corelinux or extension types into solution space applications.
Class report
- package Data
- package Data::Component View
- package Data::Analysis
- Documentation:
Classes for analysis.
- class UnitOfExecution
- Stereotype:
<<thread>>
- Documentation:
An execution path that the operating system schedules for activity.
- class ThreadIdentifier
- Stereotype:
<<type>>
- Documentation:
A unique identifier that the operating system assigns to a new path of execution.
- class OperatingSystem
- Documentation:
The operating system handles the initialization, scheduling, state, and control of execution.
- class Stack
- Documentation:
A specific area of memory used as the stack for the thread.
- class [Unnamed]
- class Resources
- Documentation:
Resources used either for managing execution, or by the executing thread.
- class Signals
- Documentation:
Either user or operating system can raise a signal on a thread.
- class Memory
- Documentation:
Local, private, and global memory.
- class [Unnamed]
- class State
- Documentation:
State information about the Unit of Execution
- package Data::libcorelinux
- package Data::Use Cases
- Stereotype:
<<useCaseModel>>
- Documentation:
A thread is a single, sequential flow of control within a program.It is also the smallest unit of execution that Linux schedules. A thread consists of a stack, the state of the CPU registers, and an entry in the execution list of the system scheduler. At the implementors discretion, each thread can share all of the process's resources (Memory, Files, Signals, etc.).
A process consists of one or more threads, data, and other resources of a program in memory. A multi-threaded application is considered when there is at least one thread in addition to the main thread of the program. A program executes when the system scheduler gives one of its threads execution control. The scheduler determines which threads should run and when they should run. Threads of lower priority may have to wait while higher priority threads complete their tasks. On multiprocessor machines, the scheduler can move individual threads to different processors to "balance" the CPU load, or providing maximum throughput.
Each thread in a process operates independently. Unless you make them visible to each other, the threads execute individually and are unaware of the other threads in a process. Collectively, the resources a thread references (stack, registers, variables, instructions, etc.) are considered as part of the context for the path of execution. Threads sharing common resources, however, may need to coordinate their work by using semaphores or other methods of interprocess communication.
- package Data::Use Cases::Participants
- class Developer
- Stereotype:
<<actor>>
- Documentation:
Developer
- class Implementor
- Superclasses:
- Data::Use Cases::Participants::Developer
- Stereotype:
<<actor>>
- Documentation:
Implementor is a developer that uses either the corelinux or extension types into solution space applications.
- Operations:
- public doWork ( )
Model dictionary
A C D I L M O P R S T U W
A
- Analysis package
- Classes for analysis.
C
- Component View package
- Configure a thread use case from package Use Cases
- Setup the profile or characteristics of a thread prior to its execution.
D
- Data package
- Developer actor from package Use Cases.Participants
- Developer
- Developer class from package Use Cases.Participants
- Developer
- doWork operation from class Use Cases.Participants.Implementor
I
- Implementor actor from package Use Cases.Participants
- Implementor is a developer that uses either the corelinux or extension types into solution space applications.
- Implementor class from package Use Cases.Participants
- Implementor is a developer that uses either the corelinux or extension types into solution space applications.
L
- libcorelinux package
M
- Memory class from package Analysis
- Local, private, and global memory.
O
- OperatingSystem class from package Analysis
- The operating system handles the initialization, scheduling, state, and control of execution.
P
- Participants package from package Use Cases
R
- Resources class from package Analysis
- Resources used either for managing execution, or by the executing thread.
- Retrieve thread information use case from package Use Cases
- Retrieve information about a thread, prior, during, or after its execution.
S
- Signals class from package Analysis
- Either user or operating system can raise a signal on a thread.
- Stack class from package Analysis
- A specific area of memory used as the stack for the thread.
- Start a thread use case from package Use Cases
- Start an asynchronous path of execution.
- State class from package Analysis
- State information about the Unit of Execution
- Stop a thread use case from package Use Cases
- Stop a thread from continuing execution.
T
- ThreadIdentifier class from package Analysis
- A unique identifier that the operating system assigns to a new path of execution.
U
- UnitOfExecution class from package Analysis
- An execution path that the operating system schedules for activity.
- Use Cases package
- A thread is a single, sequential flow of control within a program.It is also the smallest unit of execution that Linux schedules. A thread consists of a stack, the state of the CPU registers, and an entry in the execution list of the system scheduler. At the implementors discretion, each thread can share all of the process's resources (Memory, Files, Signals, etc.).
- A process consists of one or more threads, data, and other resources of a program in memory. A multi-threaded application is considered when there is at least one thread in addition to the main thread of the program. A program executes when the system scheduler gives one of its threads execution control. The scheduler determines which threads should run and when they should run. Threads of lower priority may have to wait while higher priority threads complete their tasks. On multiprocessor machines, the scheduler can move individual threads to different processors to "balance" the CPU load, or providing maximum throughput.
- Each thread in a process operates independently. Unless you make them visible to each other, the threads execute individually and are unaware of the other threads in a process. Collectively, the resources a thread references (stack, registers, variables, instructions, etc.) are considered as part of the context for the path of execution. Threads sharing common resources, however, may need to coordinate their work by using semaphores or other methods of interprocess communication.
W
- Wait for thread use case from package Use Cases
- Wait for the execution of one or more threads to complete.
SUMMARY
- Total packages reported: 6
- Total classes reported: 12
- Total operations reported: 1
- Total use cases reported: 5
Copyright © 1999, 2000 by CoreLinux Consortium
This material may be distributed only subject to the terms and conditions set forth in the
Open Publication License
|
|
|
