Add oiuser and human output formats

Oiuser is for printing user CPU time,
while the second one is human-readable.

Author: otargowski

src/limits/TimeLimitListener.cc

@@ -97,6 +97,8 @@ void TimeLimitListener::onPostExecute() {
     // TODO: run this just after child exit
     auto time = getTimeUsage();
     outputBuilder_->setRealTimeMicroseconds(time->realTimeUs);
+    outputBuilder_->setUserTimeMicroseconds(time->processTimeUs.uTimeUs);
+    outputBuilder_->setSysTimeMicroseconds(time->processTimeUs.sTimeUs);
     verifyTimeUsage(move(time));
 }
 

src/printer/HumanReadableOIOutputBuilder.cc

@@ -0,0 +1,23 @@
+#include "HumanReadableOIOutputBuilder.h"
+
+#include <sstream>
+
+namespace s2j {
+namespace printer {
+
+const std::string HumanReadableOIOutputBuilder::FORMAT_NAME = "human";
+
+std::string HumanReadableOIOutputBuilder::dump() const {
+    // This is inspired by the oiejq script
+    std::stringstream ss;
+    ss << std::endl << "-------------------------" << std::endl << "Result: ";
+    dumpStatus(ss);
+    ss << std::endl
+       << "Time used: " << static_cast<float>(milliSecondsElapsed_) / 1000
+       << "s" << std::endl
+       << "Memory used: " << memoryPeakKb_ / 1024 << "MiB" << std::endl;
+    return ss.str();
+}
+
+} // namespace printer
+} // namespace s2j

src/printer/HumanReadableOIOutputBuilder.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "OIModelOutputBuilder.h"
+
+namespace s2j {
+namespace printer {
+
+class HumanReadableOIOutputBuilder : public OIModelOutputBuilder {
+public:
+    std::string dump() const override;
+
+    const static std::string FORMAT_NAME;
+};
+
+} // namespace printer
+} // namespace s2j

src/printer/OIModelOutputBuilder.cc

@@ -24,6 +24,16 @@ OutputBuilder& OIModelOutputBuilder::setRealTimeMicroseconds(uint64_t time) {
     return *this;
 }
 
+OutputBuilder& OIModelOutputBuilder::setUserTimeMicroseconds(uint64_t time) {
+    userMilliSecondsElapsed_ = time / 1000;
+    return *this;
+}
+
+OutputBuilder& OIModelOutputBuilder::setSysTimeMicroseconds(uint64_t time) {
+    sysMilliSecondsElapsed_ = time / 1000;
+    return *this;
+}
+
 OutputBuilder& OIModelOutputBuilder::setMemoryPeak(uint64_t memoryPeakKb) {
     memoryPeakKb_ = memoryPeakKb;
     return *this;

src/printer/OIModelOutputBuilder.h

@@ -13,6 +13,8 @@ class OIModelOutputBuilder : public OutputBuilder {
 
     OutputBuilder& setCyclesUsed(uint64_t cyclesUsed) override;
     OutputBuilder& setRealTimeMicroseconds(uint64_t time) override;
+    OutputBuilder& setUserTimeMicroseconds(uint64_t time) override;
+    OutputBuilder& setSysTimeMicroseconds(uint64_t time) override;
     OutputBuilder& setMemoryPeak(uint64_t memoryPeakKb) override;
     OutputBuilder& setExitStatus(uint32_t exitStatus) override;
     OutputBuilder& setKillSignal(uint32_t killSignal) override;
@@ -24,6 +26,8 @@ class OIModelOutputBuilder : public OutputBuilder {
 
     uint64_t milliSecondsElapsed_;
     uint64_t realMilliSecondsElapsed_;
+    uint64_t userMilliSecondsElapsed_;
+    uint64_t sysMilliSecondsElapsed_;
     uint64_t memoryPeakKb_;
     uint64_t syscallsCounter_;
     uint32_t exitStatus_;

src/printer/OutputBuilder.h

@@ -36,6 +36,12 @@ class OutputBuilder {
     virtual OutputBuilder& setRealTimeMicroseconds(uint64_t time) {
         return *this;
     }
+    virtual OutputBuilder& setUserTimeMicroseconds(uint64_t time) {
+        return *this;
+    }
+    virtual OutputBuilder& setSysTimeMicroseconds(uint64_t time) {
+        return *this;
+    }
     virtual OutputBuilder& setMemoryPeak(uint64_t memoryPeakKb) {
         return *this;
     }

src/printer/UserTimeOIOutputBuilder.cc

@@ -0,0 +1,29 @@
+#include "UserTimeOIOutputBuilder.h"
+#include "common/Exception.h"
+
+#include <sstream>
+
+namespace s2j {
+namespace printer {
+
+const std::string UserTimeOIOutputBuilder::FORMAT_NAME = "oiuser";
+
+std::string UserTimeOIOutputBuilder::dump() const {
+    KillReason reason = killReason_;
+    if (reason == KillReason::NONE) {
+        if (killSignal_ > 0 || exitStatus_ > 0) {
+            reason = KillReason::RE;
+        }
+    }
+
+    std::stringstream ss;
+    ss << killReasonName(reason) << " " << exitStatus_ << " "
+       << userMilliSecondsElapsed_ << " " << 0ULL << " " << memoryPeakKb_ << " "
+       << syscallsCounter_ << std::endl;
+    dumpStatus(ss);
+    ss << std::endl;
+    return ss.str();
+}
+
+} // namespace printer
+} // namespace s2j

src/printer/UserTimeOIOutputBuilder.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "OIModelOutputBuilder.h"
+
+namespace s2j {
+namespace printer {
+
+class UserTimeOIOutputBuilder : public OIModelOutputBuilder {
+public:
+    std::string dump() const override;
+
+    const static std::string FORMAT_NAME;
+};
+
+} // namespace printer
+} // namespace s2j

src/s2japp/ApplicationSettings.cc

@@ -4,8 +4,10 @@
 
 #include "common/Utils.h"
 #include "printer/AugmentedOIOutputBuilder.h"
+#include "printer/HumanReadableOIOutputBuilder.h"
 #include "printer/OITimeToolOutputBuilder.h"
 #include "printer/RealTimeOIOutputBuilder.h"
+#include "printer/UserTimeOIOutputBuilder.h"
 #include "seccomp/policy/DefaultPolicy.h"
 #include "seccomp/policy/PermissivePolicy.h"
 
@@ -91,8 +93,12 @@ const FactoryMap<s2j::printer::OutputBuilder>
         ApplicationSettings::OUTPUT_FORMATS(
                 {{"oitt",
                   std::make_shared<s2j::printer::OITimeToolOutputBuilder>},
+                 {"human",
+                  std::make_shared<s2j::printer::HumanReadableOIOutputBuilder>},
                  {"oiaug",
                   std::make_shared<s2j::printer::AugmentedOIOutputBuilder>},
+                 {"oiuser",
+                  std::make_shared<s2j::printer::UserTimeOIOutputBuilder>},
                  {"oireal",
                   std::make_shared<s2j::printer::RealTimeOIOutputBuilder>}});
 const std::string ApplicationSettings::DEFAULT_OUTPUT_FORMAT = "oitt";