A brainstorming session on "pause-able" for & while loops.

[Wazza]

G'Day,

I have a re-occurring problem and wish to design a framework or
pattern to address it. I have some Ideas but I would like to do some
brainstorming with my peers before commencing.

The problem:

Several computational tasks I am running for my PhD work require
several weeks to complete and I will to be able to pause these tasks
and close the application periodically. It can be difficult to run a
machine several weeks without the windows operating system fowling up
at some point and requiring a restart... also it would need to be
paused so I can play crysis :) .

Any way these computations generally run in a while loop inside of one
of many (4) threads concurrently working on the problem..

mythread() { while(!finished ) { getDataToworkOn (); doWork();
postResults();} }

sometimes the algorithm is in the pooling form..

while(!solution found) { ThreadPool.Queu eUserWorkItem(t estdati[++i]) }

I am looking to create something like a SuspendableTask class... One
of the requirements is that the "SuspendableTas k" can be running many
other child "SuspendableTas ks" and when the parent task is suspended
all children must also be suspended.

Here is my thought on a solution (not actual code just a quick psuedo
code and lefty out thread safety stuff), pease post your own
thoughts...

class SuspendableTask : ISuspendableTas k
{
public static List<string, ISuspendableTas kmasterTaskList ;

bool taskPaused=fals e;
ITaskData data;
public volatile int workload=0;
public SuspendableTask (string name, ITaskData d)
{
data=d;
masterTaskList. add(name, this);
}

public static void pause(string name) {masterTaskList[name].paused =
true;}

public bool continue() {return !(paused || data.solved())} ;
}

then each thread could look something like

mythread() {
while(Suspendab leTask.masterTa skList["trainNN"].continue())
{...do work ...}
}
Well to me I think there is a more elegant solution out there.... and
I'm sure someones already using it.

thanks for any sugestions,

-dm

[Chris Mullins [MVP - C#]]

It sounds like you've got the wrong algorithm entierly, to be honest.

You high-level description just screams "MSMQ", "Persistant Storage",
"Guaranteed Delivery", "Transactio ns". You'll probably want a Queue of Work
To Do, and a Queue of Results.

Your loop would, inside a Transaction:
0 - Create a Transaction
1 - Pull the work item out of the Work Queue
2 - Process it
3 - put the data into the Result queue
4 - Commit the Transaction

On some periodic schedule (one a day, once a week, etc) you would pull out
the Results and write them to long term storage (a database / file / etc).
At the same time you would populate the Work To Do queue with items that
need processing.

This is loosley coupled approach, with persistance and transactions, is
really going to be the only type of answer you can go with given your
descriptions. Anything else runs the risk of missing work items, or having
issues if the machine crashes, your process runs out of memory, or something
else unexpected happens.

--
Chris Mullins

"Wazza" <th*********@gm ail.comwrote in message
news:11******** *************@e 34g2000pro.goog legroups.com...

G'Day,

I have a re-occurring problem and wish to design a framework or
pattern to address it. I have some Ideas but I would like to do some
brainstorming with my peers before commencing.

The problem:

Several computational tasks I am running for my PhD work require
several weeks to complete and I will to be able to pause these tasks
and close the application periodically. It can be difficult to run a
machine several weeks without the windows operating system fowling up
at some point and requiring a restart... also it would need to be
paused so I can play crysis :) .

Any way these computations generally run in a while loop inside of one
of many (4) threads concurrently working on the problem..

mythread() { while(!finished ) { getDataToworkOn (); doWork();
postResults();} }

sometimes the algorithm is in the pooling form..

while(!solution found) { ThreadPool.Queu eUserWorkItem(t estdati[++i]) }

I am looking to create something like a SuspendableTask class... One
of the requirements is that the "SuspendableTas k" can be running many
other child "SuspendableTas ks" and when the parent task is suspended
all children must also be suspended.

Here is my thought on a solution (not actual code just a quick psuedo
code and lefty out thread safety stuff), pease post your own
thoughts...

class SuspendableTask : ISuspendableTas k
{
public static List<string, ISuspendableTas kmasterTaskList ;

bool taskPaused=fals e;
ITaskData data;
public volatile int workload=0;
public SuspendableTask (string name, ITaskData d)
{
data=d;
masterTaskList. add(name, this);
}

public static void pause(string name) {masterTaskList[name].paused =
true;}

public bool continue() {return !(paused || data.solved())} ;
}

then each thread could look something like

mythread() {
while(Suspendab leTask.masterTa skList["trainNN"].continue())
{...do work ...}
}
Well to me I think there is a more elegant solution out there.... and
I'm sure someones already using it.

thanks for any sugestions,

-dm