Required changes resolved

oss-internship-2020/pffft/CMakeLists.txt

@@ -88,7 +88,7 @@ add_sapi_library(pffft_sapi
 
     INPUTS master/pffft.h master/fftpack.h
     LIBRARY pffft
-    LIBRARY_NAME pffft
+    LIBRARY_NAME Pffft
 
     NAMESPACE ""
 )

oss-internship-2020/pffft/README.md

@@ -4,7 +4,9 @@ Build System: CMake
 OS: Linux
 
 ### Check out the PFFFT library & CMake set up
-`git submodule add https://bitbucket.org/jpommier/pffft.git`
+`git clone https://github.com/doinachiroiu/sandboxed-api/tree/master/oss-internship-2020/pffft`
+
+`git submodule update --init --recursive`
 
 `mkdir -p build && cd build`
 
@@ -22,7 +24,7 @@ display custom info with
 ## ***About the project*** 
 *PFFFT library is concerned with 1D Fast-Fourier Transformations finding a
 compromise between accuracy and speed. It deals with real and complex
-vectors, both cases being illustrated in the testing part (`main_pffft.c` 
+vectors, both cases being illustrated in the testing part (`test_pffft.c` 
 for initially and original version, `main_pffft_sandboxed.cc` for our 
 currently implemented sandboxed version).
 The original files can be found at: https://bitbucket.org/jpommier/pffft/src.*
@@ -63,6 +65,7 @@ In the end, the performance of PFFFT library it is outlined by the output.*
 
 ### Bugs history
 1. [Solved] pffft benchmark bug: "Sandbox not active"  
+        
         N = 64, status OK, pffft_transform generates error 
         N > 64, status not OK
         Problem on initialising sapi::StatusOr<PFFFT_Setup *> s; the memory that stays 
@@ -76,6 +79,7 @@ In the end, the performance of PFFFT library it is outlined by the output.*
         to access the memory of object s
 
 2. [Unresolved] compiling bug: "No space left on device"
+    
         The building process creates some `embed` files that use lots of 
         memory, trying to write them on /tmp.
 

oss-internship-2020/pffft/main_pffft_sandboxed.cc

@@ -30,10 +30,10 @@
 ABSL_DECLARE_FLAG(string, sandbox2_danger_danger_permit_all);
 ABSL_DECLARE_FLAG(string, sandbox2_danger_danger_permit_all_and_log);
 
-class PffftSapiSandbox : public pffftSandbox {
+class PffftSapiSandbox : public PffftSandbox {
  public:
   std::unique_ptr<sandbox2::Policy> ModifyPolicy(
-      sandbox2::PolicyBuilder*) override {
+      sandbox2::PolicyBuilder*) {
     return sandbox2::PolicyBuilder()
         .AllowStaticStartup()
         .AllowOpen()
@@ -50,11 +50,11 @@ class PffftSapiSandbox : public pffftSandbox {
   }
 };
 
-double UclockSec(void) { return (double)clock() / (double)CLOCKS_PER_SEC; }
+double UclockSec() { return static_cast<double>(clock()) / CLOCKS_PER_SEC; }
 
 int array_output_format = 0;
 
-void ShowOutput(const char* name, int N, int cplx, float flops, float t0,
+void ShowOutput(const char* name, int n, int cplx, float flops, float t0,
                 float t1, int max_iter) {
   float mflops = flops / 1e6 / (t1 - t0 + 1e-16);
   if (array_output_format) {
@@ -64,7 +64,7 @@ void ShowOutput(const char* name, int N, int cplx, float flops, float t0,
       printf("|      n/a   ");
   } else {
     if (flops != -1) {
-      printf("N=%5d, %s %16s : %6.0f MFlops [t=%6.0f ns, %d runs]\n", N,
+      printf("n=%5d, %s %16s : %6.0f MFlops [t=%6.0f ns, %d runs]\n", n,
              (cplx ? "CPLX" : "REAL"), name, mflops,
              (t1 - t0) / 2 / max_iter * 1e9, max_iter);
     }
@@ -72,55 +72,64 @@ void ShowOutput(const char* name, int N, int cplx, float flops, float t0,
   fflush(stdout);
 }
 
-int main(int argc, char* argv[]) {
+absl::Status PffftMain() {
+  PffftSapiSandbox sandbox;
+  SAPI_RETURN_IF_ERROR(sandbox.Init());
 
+  return absl::OkStatus();
+}
+
+int main(int argc, char* argv[]) {
   // Initialize Google's logging library.
   google::InitGoogleLogging(argv[0]);
 
   gflags::ParseCommandLineFlags(&argc, &argv, true);
 
-  // Nvalues is a vector keeping the values by which iterates N, its value
+  // kTransformSizes is a vector keeping the values by which iterates n, its value
-  // representing the input length. More concrete, N is the number of
+  // representing the input length. More concrete, n is the number of
   // data points the caclulus is up to (determinating its accuracy).
   // To show the performance of Fast-Fourier Transformations the program is
-  // testing for various values of N.
+  // testing for various values of n.
-  int Nvalues[] = {64,    96,     128,        160,         192,     256,
+  constexpr int kTransformSizes[] = {64,    96,     128,        160,         192,     256,
                    384,   5 * 96, 512,        5 * 128,     3 * 256, 800,
                    1024,  2048,   2400,       4096,        8192,    9 * 1024,
                    16384, 32768};
-  int i;
 
   LOG(INFO) << "Initializing sandbox...\n";
 
   PffftSapiSandbox sandbox;
   absl::Status init_status = sandbox.Init();
 
-  LOG(INFO) << "Initialization: " << init_status.ToString().c_str() << "\n";
+  if (absl::Status status = PffftMain(); !status.ok()) {
+    LOG(ERROR) << "Initialization failed: " << status.ToString();
+    return EXIT_FAILURE;
+  }
 
-  pffftApi api(&sandbox);
+  LOG(INFO) << "Initialization: " << init_status.ToString();
+
+  PffftApi api(&sandbox);
   int cplx = 0;
 
   do {
-    for (int N : Nvalues) {
+    for (int n : kTransformSizes) {
-      const int Nfloat = N * (cplx ? 2 : 1);
+      const int n_float = n * (cplx ? 2 : 1);
-      int Nbytes = Nfloat * sizeof(float);
+      int n_bytes = n_float * sizeof(float);
 
-      float wrk[2 * Nfloat + 15 * sizeof(float)];
+      std::vector<float> work(2 * n_float + 15, 0.0);
-      sapi::v::Array<float> wrk_(wrk, 2 * Nfloat + 15 * sizeof(float));
+      sapi::v::Array<float> work_array(&work[0], work.size());
 
-      float X[Nbytes], Y[Nbytes], Z[Nbytes];
+      float x[n_bytes], y[n_bytes], z[n_bytes];
-      sapi::v::Array<float> X_(X, Nbytes), Y_(Y, Nbytes), Z_(Z, Nbytes);
+      sapi::v::Array<float> x_array(x, n_bytes), y_array(y, n_bytes), z_array(z, n_bytes);
 
-      double t0, t1, flops;
+      double t0;
+      double t1;
+      double flops;
 
-      int max_iter = 5120000 / N * 4;
+      int k;
-#ifdef __arm__
+      int max_iter = 5120000 / n * 4;
-      max_iter /= 4;
-#endif
-      int iter, k;
 
-      for (k = 0; k < Nfloat; ++k) {
+      for (k = 0; k < n_float; ++k) {
-        X[k] = 0;
+        x[k] = 0;
       }
 
       // FFTPack benchmark
@@ -130,50 +139,49 @@ int main(int argc, char* argv[]) {
 
         if (max_iter_ == 0) max_iter_ = 1;
         if (cplx) {
-          api.cffti(N, wrk_.PtrBoth()).IgnoreError();
+          api.cffti(n, work_array.PtrBoth()).IgnoreError();
         } else {
-          api.rffti(N, wrk_.PtrBoth()).IgnoreError();
+          api.rffti(n, work_array.PtrBoth()).IgnoreError();
         }
         t0 = UclockSec();
 
-        for (iter = 0; iter < max_iter_; ++iter) {
+        for (int iter = 0; iter < max_iter_; ++iter) {
           if (cplx) {
-            api.cfftf(N, X_.PtrBoth(), wrk_.PtrBoth()).IgnoreError();
+            api.cfftf(n, x_array.PtrBoth(), work_array.PtrBoth()).IgnoreError();
-            api.cfftb(N, X_.PtrBoth(), wrk_.PtrBoth()).IgnoreError();
+            api.cfftb(n, x_array.PtrBoth(), work_array.PtrBoth()).IgnoreError();
           } else {
-            api.rfftf(N, X_.PtrBoth(), wrk_.PtrBoth()).IgnoreError();
+            api.rfftf(n, x_array.PtrBoth(), work_array.PtrBoth()).IgnoreError();
-            api.rfftb(N, X_.PtrBoth(), wrk_.PtrBoth()).IgnoreError();
+            api.rfftb(n, x_array.PtrBoth(), work_array.PtrBoth()).IgnoreError();
           }
         }
         t1 = UclockSec();
 
         flops =
-            (max_iter_ * 2) * ((cplx ? 5 : 2.5) * N * log((double)N) / M_LN2);
+            (max_iter_ * 2) * ((cplx ? 5 : 2.5) * n * log((double)n) / M_LN2);
-        ShowOutput("FFTPack", N, cplx, flops, t0, t1, max_iter_);
+        ShowOutput("FFTPack", n, cplx, flops, t0, t1, max_iter_);
       }
       
       // PFFFT benchmark
       {
         sapi::StatusOr<PFFFT_Setup*> s =
-            api.pffft_new_setup(N, cplx ? PFFFT_COMPLEX : PFFFT_REAL);
+            api.pffft_new_setup(n, cplx ? PFFFT_COMPLEX : PFFFT_REAL);
 
-        LOG(INFO) << "Setup status is: " << s.status().ToString().c_str()
+        LOG(INFO) << "Setup status is: " << s.status().ToString();
-                  << "\n";
 
         if (!s.ok()) {
           printf("Sandbox failed.\n");
-          return 1;
+          return EXIT_FAILURE;
         }
 
         sapi::v::RemotePtr s_reg(s.value());
 
         t0 = UclockSec();
-        for (iter = 0; iter < max_iter; ++iter) {
+        for (int iter = 0; iter < max_iter; ++iter) {
-          api.pffft_transform(&s_reg, X_.PtrBoth(), Z_.PtrBoth(),
+          api.pffft_transform(&s_reg, x_array.PtrBoth(), z_array.PtrBoth(),
-                              Y_.PtrBoth(), PFFFT_FORWARD)
+                              y_array.PtrBoth(), PFFFT_FORWARD)
               .IgnoreError();
-          api.pffft_transform(&s_reg, X_.PtrBoth(), Z_.PtrBoth(),
+          api.pffft_transform(&s_reg, x_array.PtrBoth(), z_array.PtrBoth(),
-                              Y_.PtrBoth(), PFFFT_FORWARD)
+                              y_array.PtrBoth(), PFFFT_FORWARD)
               .IgnoreError();
         }
 
@@ -181,15 +189,15 @@ int main(int argc, char* argv[]) {
         api.pffft_destroy_setup(&s_reg).IgnoreError();
 
         flops =
-            (max_iter * 2) * ((cplx ? 5 : 2.5) * N * log((double)N) / M_LN2);
+            (max_iter * 2) * ((cplx ? 5 : 2.5) * n * log((double)n) / M_LN2);
-        ShowOutput("PFFFT", N, cplx, flops, t0, t1, max_iter);
+        ShowOutput("PFFFT", n, cplx, flops, t0, t1, max_iter);
 
-        LOG(INFO) << "N = " << N << " SUCCESSFULLY\n\n";
+        LOG(INFO) << "n = " << n << " SUCCESSFULLY";
       }
     }
 
     cplx = !cplx;
   } while (cplx);
 
-  return 0;
+  return EXIT_SUCCESS;
 }