Re: Oracle 8i - W2k - MultiProcessor and Thread Question

news.optonline.net wrote:

> Do all you agree, if a single instance of oracle is running on a
> multiprocessor system, can the threads that are launched by oracle.exe be
> on different processors then the processor the oracle.exe started on?

Seeing that I repeat this every so often in this newsgroup when OWT about threading and parallel processing rear its head.. let me repeat myself again a few times.

That is an operating system issue and *NOTHING* at all to do with Oracle itself.

That is an operating system issue and *NOTHING* at all to do with Oracle itself.

That is an operating system issue and *NOTHING* at all to do with Oracle itself.

Look at the Win32 API spec. And then you tell me where do you specify the CPU you want to have your thread run on...

--
The CreateThread function creates a thread to execute within the address 
space of the calling process. 

HANDLE CreateThread(

    LPSECURITY_ATTRIBUTES lpThreadAttributes,   // pointer to thread securit
y attributes  
    DWORD dwStackSize,  // initial thread stack size, in bytes 
    LPTHREAD_START_ROUTINE lpStartAddress,      // pointer to thread function 
    LPVOID lpParameter, // argument for new thread 
    DWORD dwCreationFlags,      // creation flags 
    LPDWORD lpThreadId  // pointer to returned thread identifier 
   );   
 

Parameters

lpThreadAttributes

Pointer to a SECURITY_ATTRIBUTES structure that determines whether the 
returned handle can be inherited by child processes. If lpThreadAttributes 
is NULL, the handle cannot be inherited. 

Windows NT: The lpSecurityDescriptor member of the structure specifies a 
security descriptor for the new thread. If lpThreadAttributes is NULL, the 
thread gets a default security descriptor. 
Windows 95: The lpSecurityDescriptor member of the structure is ignored.

dwStackSize

Specifies the size, in bytes, of the stack for the new thread. If 0 is 
specified, the stack size defaults to the same size as that of the primary 
thread of the process. The stack is allocated automatically in the memory 
space of the process and it is freed when the thread terminates. Note that 
the stack size grows, if necessary. 
CreateThread tries to commit the number of bytes specified by dwStackSize, 
and fails if the size exceeds available memory.

lpStartAddress

The starting address of the new thread. This is typically the address of a 
function declared with the WINAPI calling convention that accepts a single 
32-bit pointer as an argument and returns a 32-bit exit code. Its prototype 
is:

DWORD WINAPI ThreadFunc( LPVOID );

lpParameter

Specifies a single 32-bit parameter value passed to the thread. 

dwCreationFlags

Specifies additional flags that control the creation of the thread. If the 
CREATE_SUSPENDED flag is specified, the thread is created in a suspended 
state, and will not run until the ResumeThread function is called. If this 
value is zero, the thread runs immediately after creation. At this time, no 
other values are supported.

lpThreadId

Points to a 32-bit variable that receives the thread identifier. 

 

Return Values

If the function succeeds, the return value is a handle to the new thread.
If the function fails, the return value is NULL. To get extended error 
information, call GetLastError. 
Windows 95: CreateThread succeeds only when it is called in the context of a 
32-bit program. A 32-bit DLL cannot create an additional thread when that 
DLL is being called by a 16-bit program.

Remarks

The new thread handle is created with full access to the new thread. If a 
security descriptor is not provided, the handle can be used in any function 
that requires a thread object handle. When a security descriptor is 
provided, an access check is performed on all subsequent uses of the handle 
before access is granted. If the access check denies access, the requesting 
process cannot use the handle to gain access to the thread. 
The thread execution begins at the function specified by the lpStartAddress 
parameter. If this function returns, the DWORD return value is used to 
terminate the thread in an implicit call to the ExitThread function. Use 
the GetExitCodeThread function to get the thread's return value. 

The CreateThread function may succeed even if lpStartAddress points to data, 
code, or is not accessible. If the start address is invalid when the thread 
runs, an exception occurs, and the thread terminates. Thread termination 
due to a invalid start address is handled as an error exit for the thread's 
process. This behavior is similar to the asynchronous nature of 
CreateProcess, where the process is created even if it refers to invalid or 
missing dynamic-link libraries (DLLs). 

The thread is created with a thread priority of THREAD_PRIORITY_NORMAL. Use 
the GetThreadPriority and SetThreadPriority functions to get and set the 
priority value of a thread. 
When a thread terminates, the thread object attains a signaled state, 
satisfying any threads that were waiting on the object. 
The thread object remains in the system until the thread has terminated and 
all handles to it have been closed through a call to CloseHandle. 

The ExitProcess, ExitThread, CreateThread, CreateRemoteThread functions, and 
a process that is starting (as the result of a call by CreateProcess) are 
serialized between each other within a process. Only one of these events 
can happen in an address space at a time. This means that the following 
restrictions hold: 

·       During process startup and DLL initialization routines, new threads c
an be created, but they do not begin execution until DLL initialization is
 done for the process. 
·       Only one thread in a process can be in a DLL initialization or d
etach routine at a time. 
·       ExitProcess does not return until no threads are in thei
r DLL initialization or detach routines. 


A thread that uses functions from the C run-time libraries should use the 
beginthread and endthread C run-time functions for thread management rather 
than CreateThread and ExitThread. Failure to do so results in small memory 
leaks when ExitThread is called. 

See Also

CloseHandle, CreateProcess, CreateRemoteThread, ExitProcess, ExitThread, 
GetExitCodeThread, GetThreadPriority, ResumeThread, SetThreadPriority, 
SECURITY_ATTRIBUTES 

--
Billy