CoreLinux++
|
Goals
|
|
Developer's Corner
|
|
Contacts
|
|
|
Thread Class Report
Thread Class Report
Generated at: Thu, Mar 23, 2000
20:22:55
TABLE OF CONTENTS
- REPORT BODY
- 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
- Thread class
- ThreadContext class
- Stack class
- ThreadState class
- ThreadIdentifier class
- Signal class
- SignalHandler class
- EntryPoint class
- ThreadFrame class
- Use Cases package
- Participants package
- Developer class
- Implementor class
- Model dictionary
- SUMMARY
REPORT BODY
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
- Stereotype:
<<framework>>
- class Thread
- Stereotype:
<<utility>>
- Documentation:
Thread provides interface for the caller to create and manage asynchronous flows of execution.
To execute a thread, the caller provides a ThreadContext object that defines the information in regards to stack, state, identity, and entry point. The context is copied by the system and managed by Thread once execution begins.
- Operations:
- public ThreadIdentifier startThread ( aContext : ThreadContext )
-
- aContext : ThreadContext
- Documentation:
The context in which the thread operates.
- Stereotype:
<<constructor>>
- Documentation:
Requests that the service start a thread as described by the ThreadContext object.
- public stopThread ( aIdentifier : ThreadIdentifier )
- Stereotype:
<<destructor>>
- public void waitForThread ( aIdentifier : ThreadIdentifier )
- class ThreadContext
- Documentation:
Container for resources and information concerning the callers EntryPoint.
- Attributes:
- private theStackSize : unsigned long = 4096
-
- Documentation:
The default stack size for a thread context.
- private theState ThreadState
-
- Documentation:
The state of the thread
- private theResourceFlags : int
-
- Documentation:
The threads resource flags (VM, FILES, etc)
- Operations:
- public ThreadContext ( aExecuteAddress : int (*pFn)(*ThreadContext) )
-
- aExecuteAddress : int (*pFn)(*ThreadContext)
- Documentation:
Pointer to a function taking a ThreadContext pointer argument and returning a integer.
- Stereotype:
<<constructor>>
- Documentation:
Default constructor
- public int (*pFn)(*ThreadContext) getFunction ( [Unnamed] : void )
- Stereotype:
<<getter>>
- Constraints: {query}
- Documentation:
Returns the execution point for the callers thread.
- class Stack
- Documentation:
An area of memory, either caller defined or system allocated, that is used by the thread as a stack.
- class ThreadState
- Stereotype:
<<enumeration>>
- Documentation:
Enumerators describe the thread state of execution.
- class ThreadIdentifier
- Stereotype:
<<type>>
- Documentation:
A unique system wide identifier for a thread of execution.
- class Signal
- class SignalHandler
- Stereotype:
<<utility>>
- class EntryPoint
- Stereotype:
<<implementationClass>>
- Documentation:
Representation of callers entry point of execution. It is called from within a ThreadFrame that sets up overall exception handling, and so on.
- Operations:
- public int execute ( aContext : ThreadContext )
-
- aContext : ThreadContext
- Documentation:
A pointer to the context.
- Documentation:
The callers thread entry point.
- class ThreadFrame
- Stereotype:
<<thread>>
- Documentation:
ThreadFrame is the actual thread entry point which setups the execution frame for the caller entry point.
- Operations:
- public int entryPoint ( aContext : ThreadContext )
- Documentation:
The ThreadFrame entry point. This is the actual start address for the thread itself. The callers thread is called as a function.
- 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 E G I L M O P R S T U W
A
- Analysis package
- Classes for analysis.
C
- Component View package
D
- Data package
- Developer class from package Use Cases.Participants
- Developer
- doWork operation from class Use Cases.Participants.Implementor
E
- EntryPoint class from package libcorelinux
- Representation of callers entry point of execution. It is called from within a ThreadFrame that sets up overall exception handling, and so on.
- entryPoint operation from class libcorelinux.ThreadFrame
- The ThreadFrame entry point. This is the actual start address for the thread itself. The callers thread is called as a function.
- execute operation from class libcorelinux.EntryPoint
- The callers thread entry point.
G
- getFunction operation from class libcorelinux.ThreadContext
- Returns the execution point for the callers thread.
I
- 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.
S
- Signal class from package libcorelinux
- SignalHandler class from package libcorelinux
- Signals class from package Analysis
- Either user or operating system can raise a signal on a thread.
- Stack class from package libcorelinux
- An area of memory, either caller defined or system allocated, that is used by the thread as a stack.
- Stack class from package Analysis
- A specific area of memory used as the stack for the thread.
- startThread operation from class libcorelinux.Thread
- Requests that the service start a thread as described by the ThreadContext object.
- State class from package Analysis
- State information about the Unit of Execution
- stopThread operation from class libcorelinux.Thread
T
- theResourceFlags attribute from class libcorelinux.ThreadContext
- The threads resource flags (VM, FILES, etc)
- theStackSize attribute from class libcorelinux.ThreadContext
- The default stack size for a thread context.
- theState attribute from class libcorelinux.ThreadContext
- The state of the thread
- Thread class from package libcorelinux
- Thread provides interface for the caller to create and manage asynchronous flows of execution.
- To execute a thread, the caller provides a ThreadContext object that defines the information in regards to stack, state, identity, and entry point. The context is copied by the system and managed by Thread once execution begins.
- ThreadContext operation from class libcorelinux.ThreadContext
- Default constructor
- ThreadContext class from package libcorelinux
- Container for resources and information concerning the callers EntryPoint.
- ThreadFrame class from package libcorelinux
- ThreadFrame is the actual thread entry point which setups the execution frame for the caller entry point.
- ThreadIdentifier class from package Analysis
- A unique identifier that the operating system assigns to a new path of execution.
- ThreadIdentifier class from package libcorelinux
- A unique system wide identifier for a thread of execution.
- ThreadState class from package libcorelinux
- Enumerators describe the thread state 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
- waitForThread operation from class libcorelinux.Thread
SUMMARY
- Total packages reported: 6
- Total classes reported: 21
- Total attributes reported: 3
- Total operations reported: 8
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
|
|
|
