Perf Sched Reply Format - Brainstorming

[hgn]

Ich habe mich mal gegen JSON entschieden, können wir aber noch JSONifizieren, evtl. ist dieses Custom format einfacher für den Meschen und aber auch für dich zum parsen.

Bei den Maßeinheiten wird alles immer verstanden, also 1sec, 1usec, 1ns, 1nanosec, ...

Most simple format, one line, one name, this is will be the name of the task, the task will start immediatly and run forever (like a while 1; do; done endless loop

taskname

Dies ist identisch zu taskname : { pattern : { }}, es ist einfach eine kurzform.

To create two tasks:

taskname-1
taskname-2

To create one task with a run/sleep pattern. Der Prozess wiederholt sich unendlich, wenn sleep 1s, dann beginnt er wieder bei run 1s;

taskname : { pattern : { run 1s; sleep 1s; } }

Bisschen komplizierteres pattern

taskname : { pattern : {  run 1s; sleep 1s; run 2s; sleep 2; run 3s; sleep 3; run 4s; sleep 4;  run 5s; sleep 5; run 6s; sleep 6; } }

Same same, aber mit echtzeit priorität (fifo) und priority

taskname : { pattern : {  run 1s; sleep 1s; run 2s; sleep 2; }, sched-policy: fifo, sched-policy: 50 }

Wie oben, aber bricht nach sleep 2 ab

taskname : { pattern : {  run 1s; sleep 1s; run 2s; sleep 2; }, run-once: true }

Endlosschleife, aber mit cpu affinity auf CPU0 gesetzt

taskname : { pattern : {  run 1s; sleep 1s; run 2s; sleep 2; }, cpu-affinity: 0 }

Endlosschleife, wie " pattern: { run: 9999999999999....], mit nice level 10

taskname : { pattern : {  }, nice: 10 }

Zwei Tasks, endlosschleife, aber einer startet verzögert

taskname : { pattern : {  } }
taskname2 : { pattern : {  }, start-delay: 10sec }

Ein task, beendet sich nach 10 sekunden von selbst

taskname2 : { pattern : {  }, stop-after: 10sec }

Ein task aber nicht eine sekunde genau, sondern mit streuung danach und wahrscheinlichkeit, siehe https://wiki.linuxfoundation.org/networking/netem. Hier sollten die Ideen von netem alle eingearbeitet werden.

taskname2 : { pattern : { run: 1s 10ms 25% ; sleep 1 }, stop-after: 10sec }

Nicht als Prozess, sondern als Thread

taskname : { pattern : {  } ; type: thread}

Wie sonst auch, aber mit memory allocation von 10 mb

taskname : { pattern : {  } ; mem-dynamic: 10mb }

Standard endlosschleife, aber diesmal wird nicht ein Prozess erstellt, sondern 10, die Prozessnamen bekommen einen automatischen Namen, "taskname0", "taskname1", ... "taskname9".

taskname : { pattern : {  } ; count:10 }

Folgenes erstellt dann 10 Prozesse und 10 Threads, alle laufen volllast:

proucessname : { pattern : {  } ; count:10 }
threadname : { pattern : {  } ; count:10; type: thread }

[hgn]

@PetarGligoric fallen dir noch ein paar andere "Attribute" für einen Task ein? Beispielsweise bei der Recherche zu anderen Tools aufgefallen sind?

[PetarGligoric]

Welcher Art von Task werden wir benutzten? einfach nur Voll last oder auch mit I/O stress?

Vielleicht ein Attribut welches den Task auf eine CPU fixiert?