Re: Announcement of new C++11 library to handle measures
David Brown <david.brown@hesbynett.no> writes:
On 07/10/14 12:24, Wouter van Ooijen wrote:
c.milanesi.bg@gmail.com schreef op 07-Oct-14 12:12 PM:
David Brown wrote:
On 06/10/14 19:38, c.milanesi.bg@gmail.com wrote:
<snip>
There should be no use of exceptions or RTTI ...
I agree
There should be no reliance on the heap. ...
I agree halfway: new/new[] is ok, but delete/delete[] is not. Hence the
only practical use of new is in the startup.
I halfway agree with your halfway agreement...
Without delete/delete[]/free, you don't get memory fragmentation or
non-deterministic calls, and once you've finished your startup you
either have enough memory, or you don't. Your malloc (underlying the
new/new[]) just treats memory as a simple stack.
I've worked on two large-scale (hundreds of processors) operating systems
written in C++, and written two hypervisors in C++.
While we did not implement a heap allocator per-se, and the global
new and delete operators had function definitions that invoked a
kernel panic, we did overload the new and delete operators for classes
implementing objects with dynamic lifetimes using a pool-based allocator
to allocate from. The pool-based allocator invoked the OS page-allocator
for backing store.
David's remaining points (no RTTI, no exceptions, limited multiple inheritence[*])
remain.
[*] It was ok to inherit from multiple abstract (pure virtual) classes, but only
one concrete or partially virtual class.
Yes, compile-time polymorphism is fine. Run-time polymorphism and
virtual functions /can/ be a good thing, and often compare well to
alternatives such as tables of function pointers or large switch
statements. But they should only be used when they really are useful.
Implementing interfaces (in the java sense) is the prime use for
virtual functions in real-time code.
For example:
/**
* Pure virtual interface class for dispatchable work items.
*
* A class that needs to schedule a work task for the next available
* dispatching opportunity (which come in two flavors: next core idle
* or next guest intercept) will implement this interface and provide
* a ::do_work function to handle the work item.
*/
class c_worker {
public:
/**
* Function called when the dispatcher schedules a work item.
*
* @param arg1 An opaque argument.
* @param arg2 An opaque argument.
* @param arg3 An opaque argument.
* @param arg4 An opaque argument.
*/
virtual void do_work(void *arg1, void *arg2, void *arg3, void *arg4) = 0;
virtual ~c_worker() {};
};
/**
* Idle core entry point. Wait for work and dispatch as necessary.
*/
void
c_dispatcher::idle(void)
{
while (true) {
bool istate;
s_workitem *wip = NULL;
istate = d_lock.lock_noint();
if (!d_idlelist.is_empty()) {
wip = (s_workitem *)d_idlelist.flink();
wip->remove();
d_state = WORKING;
} else {
if (!d_interceptlist.is_empty()) {
wip = (s_workitem *)d_interceptlist.flink();
wip->remove();
d_state = WORKING;
} else {
d_idle.init();
d_state = IDLE;
}
}
d_lock.unlock_noint(istate);
if (wip != NULL) {
void *arg1 = wip->wi_arg1;
void *arg2 = wip->wi_arg2;
void *arg3 = wip->wi_arg3;
void *arg4 = wip->wi_arg4;
c_worker *wp = wip->wi_worker;
d_workerpool.free(wip);
wp->do_work(arg1, arg2, arg3, arg4);
continue;
}
d_idle.wait();
}
}
/**
* This class manages IDE and ATAPI devices.
*/
class c_ide: public c_worker {
....
/**
* Queued bootstrap task for IDE subsystem initialization. Queued to
* the bootstrap core during node initialization. Responsible for
* identification and initialization of any IDE or ATAPI devices.
*
* @param arg1 Ignored
* @param arg2 Ignored
* @param arg3 Ignored
* @param arg4 Ignored
*/
void
c_ide::do_work(void *arg1, void *arg2, void *arg3, void *arg4)
{
i_hda.init("hda");
i_hdb.init("hdb");
i_hdc.init("hdc");
i_hdd.init("hdd");
debugger.register_command("ide_read",
"ide_read [hda|hdb|hdc|hdd] sector-number",
&read);
}