Wanted: Slow CPU for testing

[helios]

I have a video player and I'd like to test its stability in low end systems. Specially whether it deadlocks when given less CPU time than it needs.
Anyone willing to put their P3/4 to good use?

EDIT: UNIX systems are welcome.

If you'd like to, you can see the code here (it's an old version, but the general structure is the same):
http://onslaught-vn.svn.sourceforge.net/viewvc/onslaught-vn/trunk/video_player/FFmpeg/video_player.cpp?revision=132&view=markup

[Incubbus]

I got an old P2 with 400MHz :D... But it´s far away at the moment... can take up to a month till I go back there^^...

[Albatross]

I have a 330 MHz Compaq, but I think I destroyed its hard disk in a experiment and its heat-sinks are probably clogged with cat hair.. Aside from that it should still work.

-Albatross

[Seraphimsan]

I have an amiga at my disposal if you'd like to cross compile to the motorola 8080 architecture :P

[m4ster r0shi]

Isn't there a way to emulate processing power shortage? Would writing a program that continuously copies a 10000-element vector of 10000-element vectors of doubles to another 10000-element vector of 10000-element vectors of doubles, and then having 50 or more instances of that program running simultaneously do the job?

[chrisname]

I believe that with the emulator Bochs, you can configure the instructions-per-second.

[helios]

Would writing a program that continuously copies a 10000-element vector of 10000-element vectors of doubles to another 10000-element vector of 10000-element vectors of doubles, and then having 50 or more instances of that program running simultaneously do the job?

Or I could use an empty loop.

Actually, what I did was run an empty loop for 90 ms and then yield for 10 ms, and ran that function in two threads. However, the bug I'm testing is hard to trigger, so I don't really trust my computer in this case. I need worst case conditions.

[m4ster r0shi]

Doesn't just adding more threads work? I tried this on my pc and the CPU usage didn't drop below 93%

#include <windows.h>
#include <ctime>
#include <process.h>
#include <iostream>

void f(void*)
{
    while(true)
    {
        int start=clock();
        while ((clock()-start)*1000.0/CLOCKS_PER_SEC<80);
        Sleep(20);
    }
}

int main()
{
    std::cout << "hit esc anytime to quit..." << std::endl;

    for (int i=0; i<40; i++)
        _beginthread(f,0,0);

    while (!(GetAsyncKeyState(VK_ESCAPE)>>15));
}

[helios]

If I wanted to rape my CPU, I would. The problem is that I actually need some CPU time to go to the process I'm debugging. Otherwise, I wouldn't bother with yielding.
When you have all your cores spending almost all of their time in the same infinite loop, you can actually see the lower priority processes crawling through their program statements. Sure, the program deadlocked then, but what does that tell me? That it won't run on a 300 MHz CPU? Well, I already knew that, I need to know how slow it can go without stopping.

What's the point of all those threads, anyway? Once there's as many threads using 50+% of single core time as there are cores, one more thread and you're past the point of diminishing returns. At least one core will always be completely busy. You could just as easily do

void f(void*){
    while(1);
}

int main(){
    for (int i=n-1;i;i--)
        _beginthread(f,0,0);
    f(0); //the pros CTRL+Break
}

I love your combination of CLOCKS_PER_SEC and Windows API calls. Classy. If only there was a function that returns a time value in known units...

[QWERTYman]

If I wanted to rape my CPU, I would.

I'd find that rather SHOCKING.

[m4ster r0shi]

Ok then. I have another idea. Why don't you write your code in a way that detects a deadlock when occurring and deals with it immediately. I understand that when you lock a resource, the resource itself is unaware of the thread that locked it, and so are the other threads that try to access that locked resource. But what if the resource was aware of the currently owning thread? In that case, it would be easy to detect a deadlock during run-time and thus take some action to solve it. You could, for example, pick a random thread involved in the deadlock, suspend all others, wait until that thread finishes its job and then resume them.

I wrote something for you to play with before experimenting with your own code. It's a multi-tasking manager emulator. You have some Resources and some Processes that consist of Operations (an Operation may be acquiring a resource, releasing a resource, operating on a resource or doing some non-resource-related operation). There's also a Process Manager to hold the whole thing together. Here I have 3 resources, A, B and C and 2 processes. The first process deals with resources A and B and the second with resource C. There is no problem here as there are no shared resources. You can easily modify this to make the second process use resource B instead of C. Now, you can see that we clearly have a problem. Try making it also use A in a way that will most probably cause a deadlock, and then find a way to detect it and address it.

The code is huge as always, but I put class declarations and main before any definition, so that you can get an idea of what's going on with a quick look at the first 120 lines.

#include <cstdlib>
#include <ctime>
#include <iostream>
#include <string>
#include <vector>
using namespace std;

struct Resource;
struct Operation;
struct Process;
struct ProcessManager;

struct Resource
{
    string name;
    bool locked;
    Process * owner;

    Resource(const char * s);
};

struct Operation
{
    int duration;
    int counter;
    virtual bool execute()=0;

    Process * owner;
    Operation();
    Operation(int n);
};

struct GetResourceOp: public Operation
{
    Resource & res;

    GetResourceOp(Resource & r);
    bool execute();
};

struct FreeResourceOp: public Operation
{
    Resource & res;

    FreeResourceOp(Resource & r);
    bool execute();
};

struct ResourceOp: public Operation
{
    Resource & res;

    ResourceOp(Resource & r,int n);
    bool execute();
};

struct NonResourceOp: public Operation
{
    NonResourceOp(int n);
    bool execute();
};

struct Process
{
    string name;
    vector<Operation*> proc_ops;
    int loops;
    int op_count;
    int cur_op;

    Process(const char * s, int n);
    ~Process();

    void operator<<(Operation * op);
    bool execute_next_op();
};

struct ProcessManager
{
    vector<Process*> procs;
    int proc_count;

    ProcessManager();

    void operator<<(Process * proc);
    void run();
};

int main()
{
    cout << "(hit enter to move to the next operation, 'q' to quit...)\n" << endl;

    Resource ResA("A");
    Resource ResB("B");
    Resource ResC("C");

    Process Proc1("Proc1",3);
    Process Proc2("Proc2",2);

    Proc1<<new GetResourceOp(ResA);
    Proc1<<new GetResourceOp(ResB);
    Proc1<<new ResourceOp(ResA,2);
    Proc1<<new ResourceOp(ResB,1);
    Proc1<<new FreeResourceOp(ResA);
    Proc1<<new FreeResourceOp(ResB);
    Proc1<<new NonResourceOp(3);

    Proc2<<new NonResourceOp(5);
    Proc2<<new GetResourceOp(ResC);
    Proc2<<new ResourceOp(ResC,3);
    Proc2<<new FreeResourceOp(ResC);
    Proc2<<new NonResourceOp(5);

    ProcessManager pm;

    pm<<&Proc1;
    pm<<&Proc2;

    pm.run();
    return 0;
}

Resource::Resource(const char * s):
    name(s),locked(false),owner(0){}

Operation::Operation(int n):
    duration(n),counter(n),owner(0){}

GetResourceOp::GetResourceOp(Resource & r):
    Operation(1),res(r){}

bool GetResourceOp::execute()
{
    cout << "Process " << owner->name;
    cout << " is trying to acquire resource ";
    cout << res.name << "..." << endl;

    if (res.locked)
    {
        cout << "But it fails, as resource is ";
        cout << "currently owned by process ";
        cout << res.owner->name << "..." << endl;
        return false;
    }

    res.locked=true;
    res.owner=owner;

    cout << "And it succeeds!" << endl;
    return true;
}

FreeResourceOp::FreeResourceOp(Resource & r):
    Operation(1),res(r){}

bool FreeResourceOp::execute()
{
    cout << "Process " << owner->name;
    cout << " is releasing resource ";
    cout << res.name << "..." << endl;

    res.locked=false;
    res.owner=0;

    return true;
}

ResourceOp::ResourceOp(Resource & r,int n):
    Operation(n),res(r){}

bool ResourceOp::execute()
{
    cout << "Process " << owner->name;
    cout << " is operating on resource ";
    cout << res.name << "..." << endl;

    if (--counter==0)
    {
        counter=duration;
        return true;
    }

    return false;
}

NonResourceOp::NonResourceOp(int n):Operation(n){}

bool NonResourceOp::execute()
{
    cout << "Process " << owner->name;
    cout << " is doing some non resource ";
    cout << "operation..." << endl;

    if (--counter==0)
    {
        counter=duration;
        return true;
    }

    return false;
}

Process::Process(const char * s, int n=1):
    name(s),loops(n),op_count(0),cur_op(0){}

Process::~Process()
{
    for (int i=0; i<op_count; i++)
        delete proc_ops[i];
}

void Process::operator<<(Operation * op)
{
    op->owner=this;
    proc_ops.push_back(op);
    op_count++;
}

bool Process::execute_next_op()
{
    if (op_count==0||loops==0) return false;

    if (proc_ops[cur_op]->execute())
    {
        cur_op++;

        if (cur_op>=op_count)
        {
            cur_op=0;
            loops--;
        }

        return true;
    }
}

ProcessManager::ProcessManager():proc_count(0)
{
    srand(time(0));
}

void ProcessManager::operator<<(Process * proc)
{
    procs.push_back(proc);
    proc_count++;
}

void ProcessManager::run()
{
    while(proc_count>0)
    {
        int cur_proc=rand()%proc_count;

        if (!procs[cur_proc]->execute_next_op())
        {
            cout << "Process " << procs[cur_proc]->name;
            cout << " finished!" << endl;
            procs.erase(procs.begin()+cur_proc);
            proc_count--;
        }

        string str;
        getline(cin,str,'\n');
        if (str[0]=='q') return;
    }

    return;
}

EDIT: Fixed a bug... Works ok now.

[helios]

Well, I said "deadlock", but it's more a problem of resource availability. Specifically, that the audio output thread is unable to give samples to OpenAL fast enough, which causes OpenAL to stop playing queued buffers, even after fresh buffers are queued. The problem is that it doesn't always seem possible to resume playing once it stops, for some reason. I need to find the boundary ratio of available CPU time to input complexity (e.g. is it a YouTube video or an HD movie) that can cause playback to stop and never resume.
It would be better to skip rendering video frames if there's no way they'll make it in time to the other end of the queue, but it's hard to know exactly when frames will be rendered, and it's even harder to know how long it takes to get across the queue.