Funktion schritt für schritt ausführen, während programmlauf und ohne Debug

lk

Meine vorstellung im groben...

int foobar (string abc)
{
    int a;
    a = 10 * 20 / 30 + 40 - 50;
    int b;
    // usw...

    return 0;
}

int main ()
{
    exec_func_step(foobar);
    return 0;
}

Schön, und was genau willst du damit machen?

Diese Angabe "Schritt für Schritt ausführen" ist ziemlich ungenau. Um Code Schritt für Schritt auszuführen, nimmt man normalerweise einen Debugger.

otze

dazu gibts doch Threads.

lk

Also, ich habe doch gesagt das ich das genau OHNE Threads oder Debugger machen MUSS. Bitte, bringt mich nicht zur verzweiflung

l'abra d'or

lk schrieb:

Also, ich habe doch gesagt das ich das genau OHNE Threads oder Debugger machen MUSS.

Und genau das wurde dir bereits gesagt: Ohne etwas an deinem Code zu verändern geht es nicht!
Entweder Threads, dann wird parallel abgearbeitet, oder du führst eine zusätzliche Variable ein die dir anzeigt, welche Operation du nun ausführen sollst (siehe direkt die erste Antwort von SeppJ).

Du könntest mal genauer erklären was die Aufgabenstellung ist, dann gibt es auch konkretere Tipps.

OHNE ... Debugger machen MUSS

Das hast du aber jetzt reineditiert...

Aber könntest du trotzdem mal sagen, wie genau du dir das vorstellst?
Warum funktioniert das was SeppJ vorgeschlagen hat nicht?

lk

Der code von SeppJ funcktioniert, ist blos überhapt nicht was ich meinte.
Also, ich wollte auf eine klasse hinaus, der man funktions pointer hinzufügen kann, und danach alle ( mit zb. MyClass.exec_all(); ) gleichzeitig ausführen kann.
Ich habe ja nicht wirklich ahnung, aber im groben stelle ich's mir ungefär so vor(warscheinlich völlig falsch):

class Tmulti
{
public:
    void addF (FUNC f); // FUNC ist soll ein funktionspointer sein
    void exec_all ()
    {
        bool end = false;
        while (!end)
        {
            for(int i=0; i<f_max; i++) // f_max: anzahl an functionen
            {
                dostep(fs[i], 10); // 10 schritte auf einmal
            }
        }
    }
};

knivil

Nein das geht nicht (ohne weiteres). Ich glaube kaum, dass das eine moegliche Aufgabenstellung in der Praxis ist. Wahrscheinlich hast du einfach nur was falsch verstanden.

SeppJ

Da musst du weiter ausholen. Ziemlich weit. Du müsstest etwas einem Threadsystem vergleichbares emulieren. Dafür musst du spezielle Eigenschaften der Maschinensprache, in der die Funktion vorliegt, berücksichtigen, wodurch das ganze auch sehr unportabel wird.

Gegenfrage: Das was du vor hast ist sehr ungewöhnlich. Kannst du mal deine Motivation erläutern? Vermutlich gibt es bessere, deutlich einfachere Lösungen.

lk

Also, ich wollte einfach mein eigenes (simples und primitives, lol) system schreiben, dass mehr zeugs gleichzeitig ausfüren kann. (und ja, ich habe da schon so gedacht es könnte was mit maschienen sprache zu tun haben...)

Fellhuhn

Geht so nicht. Lass es einfach.

lk

Fellhuhn schrieb:

Geht so nicht. Lass es einfach.

Nee, danke. Ich bleib dran :3

Fellhuhn

Selbst wenn du so einen Kram machst wie den Funktionscode häppchenweise in andere Speicherbereiche zu kopieren und dann auszuführen, hast du immernoch das Problem mit dem Stack der invalide wird. Egal was du vor hast: lohnt nicht, bringt nichts, macht keinen Sinn.

l'abra d'or

"Mehr Zeugs gleichzeitig" ist gut... Du zerhackst die Funktionen und führst Teile hintereinander aus. Wenn du in Mathe gut bist, weißt du dass am Ende die gleiche Zeit flöten gegangen ist. Du brauchst sogar länger, weil du nen gewissen Overhead einbaust. Und parallel geht da gleich gar nix, denn deine Abarbeitung findet in einer einzigen Funktion statt, die dann dein ganzes Programm blockiert. Da kannst du die Funktionen gleich alle hintereinander ausführen.

Und eine wichtige Sache vergisst du komplett: Multiprozessorsysteme. Viel Spaß, wenn du selber versuchst, die einzelnen Funktionshappen auf mehrere Kerne zu verteilen, damit du wirklich parallele Abarbeitung erhältst

Und jetzt mal wieder ernst: Warum nicht threads verwenden? Das ist genau das was du haben willst und mit etwas Grundwissen (von dem du deutlich mehr brauchst, wenn du das echt selber hinbiegen willst - gib dir 2 Jahre...) kommst du da bald mit zurecht.

lk

ok, ich werd's mit Threads versuchen. Kennt jemand gute toturials (MS Visual c++) oder kann mir welchen beispielcode mit möglichst viel commentaren geben ? Wär nett :3

pumuckl

l'abra d'or schrieb:

Und eine wichtige Sache vergisst du komplett: Multiprozessorsysteme. Viel Spaß, wenn du selber versuchst, die einzelnen Funktionshappen auf mehrere Kerne zu verteilen, damit du wirklich parallele Abarbeitung erhältst

Warum um Gottes Willen sollte er das tun? damit er ganze Cache-Inhalte zwischen den Kernen hin- und herschaufeln lässt?

Für das was er vorhat empfehle ich dem OP ein wenig ordentliche Lektüre über Compilerbau und Parallel-Abläufe. Das sollte ihn ein paar Monate beschäftigen...

l'abra d'or

Wahrscheinlich krieg ich jetzt (wieder) den Kopf abgeschlagen aber:
Google -> Windows Threads
Liefert dir als ersten Treffer die Windows Doku zum Thema. Und da gibts richtig viel zum Thema zu lesen, mit viel Beispielcode und viel Kommentaren darin.

Willst du dich nicht nur auf Windows festlegen, kann ein Blick in Richtung boost.threads oder C++0x nicht schaden (der neue Standard soll ja Klassen für Threads enthalten).

l'abra d'or

pumuckl schrieb:

l'abra d'or schrieb:

Und eine wichtige Sache vergisst du komplett: Multiprozessorsysteme. Viel Spaß, wenn du selber versuchst, die einzelnen Funktionshappen auf mehrere Kerne zu verteilen, damit du wirklich parallele Abarbeitung erhältst

Warum um Gottes Willen sollte er das tun? damit er ganze Cache-Inhalte zwischen den Kernen hin- und herschaufeln lässt?

Weil es durchaus Betriebssysteme geben soll, die einzelne Threads auf verschiedene Kerne verteilen können. Ich wollte eigentlich nur darauf hinaus, dass es ziemlich aufwändig ist, die Effizienz von nativen Threads selber nachzubauen.

lk

mal kurz eine Frage: Was sind eigentlich Handles, und wozu dienen diese ?

knivil

Du solltest dich bei deinem Kenntnisstand erstmal durch die Grundlagen arbeiten.