Reorganization

- All garlic stuff is moved into garlic/
- Group the overlay index by sections
- Add a garlic/default.nix link to the main default.nix, so we can
  build derivations at garlic/

garlic/apps/index.nix

@@ -0,0 +1,55 @@
+{
+  super
+, self
+, bsc
+, garlic
+, callPackage
+}:
+
+{
+  nbody = callPackage ./nbody/default.nix {
+    gitBranch = "garlic/seq";
+  };
+
+  saiph = callPackage ./saiph/default.nix {
+    cc = bsc.clangOmpss2;
+  };
+
+  creams = callPackage ./creams/default.nix {
+    gnuDef   = self.gfortran10 ; # Default GNU   compiler version
+    intelDef = bsc.icc    ; # Default Intel compiler version
+    gitBranch = "garlic/mpi+send+seq";
+  };
+
+  creamsInput = callPackage ./creams/input.nix {
+    gitBranch = "garlic/mpi+send+seq";
+  };
+
+  hpcg = callPackage ./hpcg/default.nix {
+    gitBranch = "garlic/oss";
+  };
+
+  bigsort = {
+    sort = callPackage ./bigsort/default.nix {
+      gitBranch = "garlic/mpi+send+omp+task";
+    };
+
+    genseq = callPackage ./bigsort/genseq.nix { };
+
+    shuffle = callPackage ./bigsort/shuffle.nix { };
+  };
+
+  heat = callPackage ./heat/default.nix { };
+
+  miniamr = callPackage ./miniamr/default.nix {
+    variant = "ompss-2";
+  };
+
+  ifsker = callPackage ./ifsker/default.nix { };
+
+  lulesh = callPackage ./lulesh/default.nix { };
+
+  hpccg = callPackage ./hpccg/default.nix { };
+
+  fwi = callPackage ./fwi/default.nix { };
+}

garlic/default.nix

@@ -0,0 +1 @@
+import ../default.nix

garlic/ds/index.nix

@@ -0,0 +1,40 @@
+{
+  super
+, self
+, bsc
+, garlic
+, callPackage
+}:
+
+with garlic.pp;
+
+let
+  exp = garlic.exp;
+in
+{
+  nbody = with exp.nbody; {
+    baseline = merge [ baseline ];
+    small = merge [ small ];
+    jemalloc = merge [ baseline jemalloc ];
+    #freeCpu  = merge [ baseline freeCpu ];
+    ctf = merge [ ctf ];
+  };
+
+  hpcg = with exp.hpcg; {
+    oss = merge [ oss ];
+  };
+
+  saiph = with exp.saiph; {
+    numcomm = merge [ numcomm ];
+    granularity = merge [ granularity ];
+  };
+
+  heat = with exp.heat; {
+    test = merge [ test ];
+  };
+
+  creams = with exp.creams.ss; {
+    ss.hybrid = merge [ hybrid ];
+    ss.pure = merge [ pure ];
+  };
+}

garlic/exp/index.nix

@@ -0,0 +1,93 @@
+{
+  super
+, self
+, bsc
+, garlic
+, callPackage
+}:
+
+{
+  nbody = rec {
+    baseline = callPackage ./nbody/nblocks.nix { };
+
+    # Experiment variants
+    small = baseline.override {
+      particles = 12 * 4096;
+    };
+    # TODO: Update freeCpu using a non-standard pipeline
+    #freeCpu = baseline.override { freeCpu = true; };
+    jemalloc = baseline.override { enableJemalloc = true; };
+
+    # Some experiments with traces
+    trace = {
+      # Only one unit repeated 30 times
+      baseline = small.override {
+        enableCTF = true;
+        loops = 30;
+        steps = 1;
+      };
+
+      # Same but with jemalloc enabled
+      jemalloc = trace.baseline.override {
+        enableJemalloc = true;
+      };
+    };
+  };
+
+  saiph = {
+    numcomm = callPackage ./saiph/numcomm.nix { };
+    granularity = callPackage ./saiph/granularity.nix { };
+  };
+
+  creams = {
+    ss = {
+      pure = callPackage ./creams/ss+pure.nix { };
+      hybrid = callPackage ./creams/ss+hybrid.nix { };
+    };
+  };
+
+  hpcg = rec {
+    #serial = callPackage ./hpcg/serial.nix { };
+    #mpi = callPackage ./hpcg/mpi.nix { };
+    #omp = callPackage ./hpcg/omp.nix { };
+    #mpi_omp = callPackage ./hpcg/mpi+omp.nix { };
+    #input = callPackage ./hpcg/gen.nix {
+    #  inherit (bsc.garlic.pp) resultFromTrebuchet;
+    #};
+    genInput = callPackage ./hpcg/gen.nix {
+      inherit (bsc.garlic.pp) resultFromTrebuchet;
+    };
+
+    oss = callPackage ./hpcg/oss.nix {
+      inherit genInput;
+    };
+  };
+
+  heat = {
+    test = callPackage ./heat/test.nix { };
+  };
+
+  bigsort = rec {
+    genseq = callPackage ./bigsort/genseq.nix {
+      n = toString (1024 * 1024 * 1024 / 8); # 1 GB input size
+      dram = toString (1024 * 1024 * 1024); # 1 GB chunk
+    };
+
+    shuffle = callPackage ./bigsort/shuffle.nix {
+      inputTre = genseq;
+      n = toString (1024 * 1024 * 1024 / 8); # 1 GB input size
+      dram = toString (1024 * 1024 * 1024); # 1 GB chunk
+      inherit (bsc.garlic.pp) resultFromTrebuchet;
+    };
+
+    sort = callPackage ./bigsort/sort.nix {
+      inputTre = shuffle;
+      inherit (bsc.garlic.pp) resultFromTrebuchet;
+      removeOutput = false;
+    };
+  };
+
+  slurm = {
+    cpu = callPackage ./slurm/cpu.nix { };
+  };
+}

garlic/fig/index.nix

@@ -0,0 +1,57 @@
+{
+  super
+, self
+, bsc
+, garlic
+, callPackage
+}:
+
+let
+  rPlot = garlic.pp.rPlot;
+  ds = garlic.ds;
+in
+{
+  nbody = {
+    baseline = rPlot {
+      script = ./nbody/baseline.R;
+      dataset = ds.nbody.baseline;
+    };
+    small = rPlot {
+      script = ./nbody/baseline.R;
+      dataset = ds.nbody.small;
+    };
+    jemalloc = rPlot {
+      script = ./nbody/jemalloc.R;
+      dataset = ds.nbody.jemalloc;
+    };
+    #freeCpu = rPlot {
+    #  script = ./nbody/freeCpu.R;
+    #  dataset = ds.nbody.freeCpu;
+    #};
+    ctf = rPlot {
+      script = ./nbody/baseline.R;
+      dataset = ds.nbody.ctf;
+    };
+  };
+
+  hpcg = {
+    oss = with ds.hpcg; rPlot {
+      script = ./hpcg/oss.R;
+      dataset = oss;
+    };
+  };
+
+  saiph = {
+    granularity = with ds.saiph; rPlot {
+      script = ./saiph/granularity.R;
+      dataset = granularity;
+    };
+  };
+
+  heat = {
+    test = with ds.heat; rPlot {
+      script = ./heat/test.R;
+      dataset = test;
+    };
+  };
+}

garlic/index.nix

@@ -0,0 +1,128 @@
+{
+  super
+, self
+, bsc
+, callPackage
+}:
+
+{
+  unsafeDevelop = callPackage ./develop/default.nix {
+        extraInputs = with self; [
+          coreutils htop procps-ng vim which strace
+          tmux gdb kakoune universal-ctags bashInteractive
+          glibcLocales ncurses git screen curl
+          # Add more nixpkgs packages here...
+          bsc.slurm bsc.clangOmpss2 bsc.icc bsc.mcxx bsc.perf
+          # Add more bscpkgs packages here...
+        ];
+  };
+
+  develop = bsc.garlic.stages.exec rec {
+    nextStage = bsc.garlic.stages.isolate {
+      nextStage = bsc.garlic.unsafeDevelop;
+      nixPrefix = bsc.garlic.targetMachine.config.nixPrefix;
+      extraMounts = [ "/tmp:$TMPDIR" ];
+    };
+    nixPrefix = bsc.garlic.targetMachine.config.nixPrefix;
+    # This hack uploads all dependencies to MN4
+    pre = let
+      nixPrefix = bsc.garlic.targetMachine.config.nixPrefix;
+      stageProgram = bsc.garlicTools.stageProgram;
+    in
+    ''
+      # Hack to upload this to MN4: @upload-to-mn@
+
+      # Create a link to the develop script
+      ln -fs ${nixPrefix}${stageProgram nextStage} .nix-develop
+    '';
+    post = "\n";
+  };
+
+  # Configuration for the machines
+  machines = callPackage ./machines.nix { };
+
+  report = callPackage ./report.nix {
+    fig = bsc.garlic.fig;
+  };
+
+  sedReport = callPackage ./sedReport.nix {
+    fig = bsc.garlic.fig;
+  };
+
+  bundleReport = callPackage ./bundleReport.nix {
+    fig = bsc.garlic.fig;
+  };
+
+  reportTar = callPackage ./reportTar.nix {
+    fig = bsc.garlic.fig;
+  };
+
+  # Use the configuration for the following target machine
+  targetMachine = bsc.garlic.machines.mn4;
+
+  # Load some helper functions to generate app variants
+
+  stdexp = callPackage ./stdexp.nix {
+    inherit (bsc.garlic) targetMachine stages;
+  };
+
+  # Execution stages
+  stages = {
+    sbatch     = callPackage ./stages/sbatch.nix { };
+    srun       = callPackage ./stages/srun.nix { };
+    control    = callPackage ./stages/control.nix { };
+    exec       = callPackage ./stages/exec.nix { };
+    extrae     = callPackage ./stages/extrae.nix { };
+    valgrind   = callPackage ./stages/valgrind.nix { };
+    perf       = callPackage ./stages/perf.nix { };
+    isolate    = callPackage ./stages/isolate { };
+    runexp     = callPackage ./stages/runexp { };
+    trebuchet  = callPackage ./stages/trebuchet.nix { };
+    strace     = callPackage ./stages/strace.nix { };
+    unit       = callPackage ./stages/unit.nix { };
+    experiment = callPackage ./stages/experiment.nix { };
+  };
+
+  # Tests (move to bsc ?)
+  mpptest = callPackage ./mpptest { };
+
+  ppong = callPackage ./ppong {
+    mpi = bsc.mpi;
+  };
+
+  hist = callPackage ./pp/hist { };
+
+  tool = callPackage ./sh/default.nix {
+    sshHost = "mn1";
+  };
+
+  # Post processing tools
+  pp = with bsc.garlicTools; rec {
+    store = callPackage ./pp/store.nix { };
+    resultFromTrebuchet = trebuchetStage: (store {
+      experimentStage = getExperimentStage trebuchetStage;
+      inherit trebuchetStage;
+    });
+    timetable = callPackage ./pp/timetable.nix { };
+    rPlot = callPackage ./pp/rplot.nix { };
+    timetableFromTrebuchet = tre: timetable (resultFromTrebuchet tre);
+    mergeDatasets = callPackage ./pp/merge.nix { };
+
+    # Takes a list of experiments and returns a file that contains
+    # all timetable results from the experiments.
+    merge = exps: mergeDatasets (map timetableFromTrebuchet exps);
+  };
+
+  # Apps for Garlic
+  apps = callPackage ./apps/index.nix { };
+
+  # Experiments
+  exp = callPackage ./exp/index.nix { };
+
+  # Datasets used in the figures
+  ds = callPackage ./ds/index.nix { };
+
+  # Figures generated from the experiments
+  fig = callPackage ./fig/index.nix { };
+
+}