Common name for a "Task Loop"

How about round-robin scheduling?

It includes the idea of allocating time slices to tasks, which a simple task loop does not do.

I've seen:

- task loop

- The Big Loop

- "bare metal"

- A "no O/S" solution.

Google is no help at all.

It's apparently sufficiently obscure to defy standard naming.

That's kind of what I found, too.

It's a form of non-preemptive multitasking, but it's by no means the only way to implement that, so you can't really call it that.

Which is odd, because if you were to count actual processors out there then some variant of it is probably the most Embedded architecture.

I've always called it while(1)OS.

Hmm. That actually gets some hits. There seems to be no consensus on these terms, though.

Rob - that's what I've always called it too. Not really Google-able however...

--Mark

I'd call that a polling loop, since it polls each task to see if it's ready. But I don't know if that's a standard term. There's a DSL for generating these things (see "Atom" under

Until I read your reply, this was _exactly_ what I was going to say.

It _is_ a polling loop (or polling architecture if you want to distinguish it from an interrupt architecture.)

Simon.

Kludge?

OK, OK, I've done it too...

I don't think it's a klugde in a small enough application. It has it's downsides, true, but it works just fine if you're careful.

Nah. It's anything but, really. There's just a slightly ... jerky continuum of increasing abstraction starting with a big loop being the least abstract ( and potentially the most deterministic ).

Assuming a single thread, I would just call this a 'super loop', and, to the best of my knowledge, believe that is the common way of describing it. A quick google for '"super loop" software' brings the following:

which I think is inline with your structure.

Regards, Richard.

• formatting link
  The de facto standard, downloaded every 4.2 minutes during 2015.

• formatting link
  IoT, Trace, Certification, TCP/IP, FAT FS, Training, and more...

I guess I'm going to have to be happy with "Superloop". It doesn't seem to capture the more-disciplined nature of what I was expressing, which basically implements a cooperative multitasking scheduler.

Mostly I need something to point to when some newbie on a forum is looking for an alternative to doing most of their processing in ISRs, because they can't imagine the "set a flag and do it later" notion.

Tim, the "Superloop" is quite ok as a term. I'm using "main loop" by myself

- I don't know why exactly, maybe because it resides in main() ? :D - and because the "super" in superloop seems to me too strong. What's so "super" about it?

However, you use "task" for a finite state machine. The "cooperative" thing has nothing to do with your code, basically because there aren't "tasks". "Cooperative" term is used on real multi-tasking systems in opposition to "preemtive". But I think you know very well that.

For me a "task" is a code that has (or can have) an infinite loop inside, and usually doesn't return. A cooperative multitasking system is exactly like a preemtive one, but just without the preemtion. The only way to give control to other tasks is with some yield() routine. The scheduler is simpler than for a preemtive system, but it is no way close to what you are describing in your example.

What you describe is a round robin scheduler, with each task running to completion once it has something to do. It's a common technique where you don't want or need the complexity of a real time OS. For a slightly more formal solution, you can encapsulate that idea into a variable length table of function pointers, where tasks can be set sleeping, ready, running etc. Include a count of clock ticks that say how often the task runs to provide priority scheduling. Implement each task as a state machine, with simple message passing between tasks, always dependent on the next message to run and you have a compact and efficient real time OS applicable to any processor. The advantage is that it can all be written in C, with no fussy processor specific context switching code.

You can do all that in not much more than a page of C :-)...

Regards,

Chris

I always called it a "Round Robin" type, but I could be wrong.

That's one I'll actually disagree with. Round robin to me implies a lack of prioritization, whereas this is explicitly priority based. It's the difference between:

while(1) { for {task=tasklisthead; task->fptr != NULL; task++) { if (task->readyflag) { task->fptr(); /* The break makes it priority, without it is round robin. */ break; } } }