🚀 go-pugleaf

"Dennis Jones" wrote:
> performance hit because the OS will efficiently avoid switching into the
> context of a thread that is waiting for an OS event.  On the other hand,
if
> every one of those threads is busy doing something (or worse, is in a
tight
> loop watching the state of a flag), then the amount of context switching
> would probably be significantly measureable, and seriously affecting
> performance.

I have tried to write a program to measure this, but it is quite tricky. I
will post the code at the bottom. Use commandline bcc32 to compile it.
Warning: very not userfriendly, use at own risk, etc.

Program takes 2 parameters:
threads #numthreads #delaycounter

#numthreads = the number of threads the program creates before beginning
#delaycounter = a number that is used to slow things down. 1000 is approx 1
sec on my computer, 750MHz.

I don't know if a conclusion can be drawn, but 2024 is max threads for my
machine and the program runs about 40 percent slower. 1 thread takes 1040
msec, 2024 threads take 1412 msec to complete.

I have tried to measure only the difference context switching, but I don't
know how succesful I was.

HTH,

Micha.


---code threads.cpp---

#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>

int num_iterations;
bool active;

unsigned long __stdcall thread_func(void* data)
{
unsigned __int64 i;

while (!active) {}
for (i=0; i < (*reinterpret_cast<unsigned __int64*>(data)); i++);

return NULL;
}

int main(int argc, char** argv)
{
HANDLE* tid;
int i, j, numthreads;
unsigned __int64 count;
DWORD start;

if (argc < 3)
    return 1;

// init threads
printf("Creating threads...");
active = false;
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
numthreads = atoi(argv[1]);
count = atoi(argv[2]);
count *= 100000/numthreads;
tid = new HANDLE[numthreads];
printf("%d, count to %Lu\n", numthreads, count);
for (i=0; i<numthreads; i++)
    {
    tid[i] = CreateThread(NULL, 0, thread_func, &count, CREATE_SUSPENDED,
NULL);
    if (tid[i] == NULL)
        {
        printf ("error create thread\n");
        }
    SetThreadPriority(tid[i], THREAD_PRIORITY_IDLE);
    }

// start!
printf("Resuming...\n", MAXIMUM_WAIT_OBJECTS);
for (i=0; i<numthreads; i++)
    ResumeThread(tid[i]);
active = true;

// wait for threads to terminate
start = GetTickCount();
for (i=0; i<numthreads; i+=j)
    {
    j = numthreads-i;
    if (j > MAXIMUM_WAIT_OBJECTS)
        j = MAXIMUM_WAIT_OBJECTS;
    if (WaitForMultipleObjects(j, tid+i, TRUE, INFINITE) == WAIT_FAILED)
        printf("wait failed: error=%u\n", GetLastError());
    }
printf("Time=%dms\n", GetTickCount()-start);

delete[] tid;
}