Ferdig med 10

lab_2/10_answer.md

@@ -0,0 +1,8 @@
+# How many steps m you can run the program?
+The limit is somewhere between m=6300000 m=6400000 on my laptop
+
+# How do you recognize that the system is running out of memory?
+The memory and swap gets filled up and the process gets killed by systemd-oomd
+
+# Plot the runtime
+See 10_runtime_plot.png

lab_2/10_memleak/Makefile

@@ -0,0 +1,18 @@
+binary = memleak
+folder = memleak
+objects = $(patsubst %.cpp,%.o,$(wildcard *.cpp))
+
+run: $(binary)
+	./$(binary) 7 100000000
+
+$(binary): $(objects)
+	g++ -o $@ $^
+
+clean:
+	rm -f *.o
+
+clear: clean
+	rm -f *.zip $(binary)
+
+zip: clean
+	zip $(folder) Makefile *.cpp *.h

lab_2/10_memleak/chain-random-walk.cpp

@@ -0,0 +1,78 @@
+#include <cstdlib>
+#include <iomanip>
+#include <iostream>
+
+#include "chain-random-walk.h"
+
+using namespace crw;
+
+namespace {
+   // set each element forward or backward by 1, at random
+   void stochastic_unit_step(long size, float config[])
+   {
+      for(long i = 0; i < size; i++)
+         if(std::rand() % 2 == 0) config[i]++;
+         else config[i]--;
+   }
+   
+   void shift_centre_to_origin(long size, float config[])
+   {
+       double sum = 0.0;
+       for(long i = 0; i < size; i++) sum += config[i];
+       for(long i = 0; i < size; i++) config[i] -= sum/size;
+   }
+   
+   const int el_out_max = 9;  // show at most the first nine elements
+}
+
+float crw::elongation(long size, float config[])
+{
+   float min = config[0];
+   float max = config[0];
+   
+   for(long i = 1; i < size; i++)
+      if(config[i] > max) max = config[i];
+      else if(config[i] < min) min = config[i];
+
+   return max - min;
+}
+
+float* crw::step(long size, float previous[])
+{
+   // allocate the next configuration
+   float* config = new float[size]();
+    
+   // first, let the chain contract: each element is attracted by its neighbours
+   for(long i = 0; i < size; i++)
+      config[i] = 0.5*previous[i] + 0.25*previous[(i-1) % size]
+                                  + 0.25*previous[(i+1) % size];
+
+   stochastic_unit_step(size, config);  // actual random walk step
+   shift_centre_to_origin(size, config);  // shift such that the average remains zero
+
+   return config;
+}
+
+void crw::output(long no, long size, float present[], float extreme[], double avg_el)
+{
+   /* output statistics over the run so far 
+    */
+   std::cout << std::setw(12) << no << "\t" << std::setprecision(3) << std::fixed
+             << std::setw(6) << elongation(size, present) << " "
+             << std::setprecision(7) << std::setw(10) << avg_el << " " << std::setprecision(5) 
+             << std::setw(9) << elongation(size, extreme) << std::setprecision(3) << "\t\t";
+   
+   /* display the present configuration, showing up to <el_out_max> element coordinates */
+   for(long i = 0; (i < size) && (i < el_out_max); i++)
+       std::cout << std::setw(7) << present[i] << " ";
+   if(size > el_out_max) std::cout << "...";
+   std::cout << "\t\t";
+    
+   /* display the most extreme configuration so far,
+    * showing up to <el_out_max> element coordinates
+    */
+   for(long i = 0; (i < size) && (i < el_out_max); i++)
+       std::cout << std::setw(7) << extreme[i] << " ";
+   if(size > el_out_max) std::cout << "...";
+   std::cout << "\n";
+}

lab_2/10_memleak/chain-random-walk.h

@@ -0,0 +1,11 @@
+#ifndef CHAIN_RANDOM_WALK_H
+#define CHAIN_RANDOM_WALK_H
+
+namespace crw
+{
+   float elongation(long size, float config[]);
+   float* step(long size, float previous[]);
+   void output(long no, long size, float present[], float extreme[], double avg_el);
+}
+
+#endif

lab_2/10_memleak/const_Nm_timings.csv

@@ -0,0 +1,10 @@
+1024, 43.46
+512, 44.03
+256, 45.26
+128, 46.54
+64, 47.82
+32, 50.89
+16, 56.13
+8, 60.42
+4, 59.66
+2, 56.71

lab_2/10_memleak/const_m_timings.csv

@@ -0,0 +1,10 @@
+1024, 43.84
+512, 22.24
+256, 11.32
+128, 5.86
+64, 3.05
+32, 1.61
+16, 0.89
+8, 0.47
+4, 0.24
+2, 0.15

lab_2/10_memleak/memleak.cpp

@@ -0,0 +1,62 @@
+#include <cassert>
+#include <cstdlib>
+#include <ctime>
+
+#include "chain-random-walk.h"
+
+namespace {
+   constexpr int default_size = 7;
+   constexpr int default_steps = 100000000;
+   constexpr int outlines = 25;
+}
+
+/* first argument: array size
+ * second argument: number of steps
+ */
+int main(int argc, char** argv)
+{
+   long size = default_size;
+   if(argc > 1) size = std::atol(argv[1]);
+   assert(size > 0);
+    
+   long steps = default_steps;
+   if(argc > 2) steps = std::atol(argv[2]);
+   assert(steps > 0);
+    
+   long outfreq = steps / outlines;
+   if(outfreq < 1) outfreq = 1;
+    
+   /* the configuration is given by an array of float numbers */
+   float* present_configuration = new float[size]();
+
+   /* store the one with greatest deviation between min and max element */
+   float* extreme_configuration = present_configuration;
+   float extreme_elongation = 0.0;
+   double el_sum = 0.0;
+   double el_avg = 0.0;
+
+   std::srand(std::time(nullptr)); // initialize the random number generator
+   
+   for(long i = 0; i < steps; i++)
+   {
+      if(i % outfreq == 0)
+         crw::output(i, size, present_configuration, extreme_configuration, el_avg);
+      
+      /* here we are calling the random walk step;
+       * this returns a new configuration (float array) on the heap
+       */
+      present_configuration = crw::step(size, present_configuration);
+      float present_elongation = crw::elongation(size, present_configuration);
+
+      if(present_elongation > extreme_elongation)
+      {
+          extreme_configuration = present_configuration;
+          extreme_elongation = present_elongation;
+      }
+      el_sum += present_elongation;
+      el_avg = el_sum / (i + 1.0);
+   }
+   crw::output(steps, size, present_configuration, extreme_configuration, el_avg);
+
+   delete[] present_configuration;
+}

lab_2/10_memleak/plot.py

@@ -0,0 +1,34 @@
+import matplotlib.pyplot as plt
+import matplotlib.cbook as cbook
+
+import numpy as np
+import pandas as pd
+
+f = open('const_m_timings.csv', 'r')
+x1 = []
+y1 = []
+for l in f.readlines():
+    l = l.split(',')
+    x1.append(l[0])
+    y1.append(float(l[1]))
+
+f = open('const_Nm_timings.csv', 'r')
+x2 = []
+y2 = []
+for l in f.readlines():
+    l = l.split(',')
+    x2.append(l[0])
+    y2.append(float(l[1]))
+
+plt.plot(x1, y1, label = 'constant m')
+plt.plot(x2, y2, label = 'constant Nm')
+for i in range(len(x1)):
+        plt.text(i,y1[i],str(y1[i])+'s')
+for i in range(len(x2)):
+        plt.text(i,y2[i],str(y2[i])+'s')
+plt.title('runtime t as a function of number of steps N')
+plt.xlabel('N')
+plt.ylabel('time (s)')
+plt.grid()
+plt.legend() 
+plt.show()

lab_2/10_memleak/time_Nm.nu

@@ -0,0 +1,6 @@
+for x in [1024 512 256 128 64 32 16 8 4 2] {
+$x | into string | save --append log.csv;
+", " | save --append log.csv;
+let m = 2048000000 / $x;
+time -f %e -a -o  log.csv ./memleak $x $m;
+};