git.gag.com Git - debian/gnuradio/blob - gcell/apps/benchmark_roundtrip.cc

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright 2007,2008,2009 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GNU Radio
   6  *
   7  * GNU Radio is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3, or (at your option)
  10  * any later version.
  11  *
  12  * GNU Radio is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #if defined(HAVE_CONFIG_H)
  23 #include <config.h>
  24 #endif
  25 #include <gcell/gc_job_manager.h>
  26 #include <gnuradio/omni_time.h>
  27 #include <getopt.h>
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <boost/scoped_array.hpp>
  31 #include <assert.h>
  32
  33 // handle to embedded SPU executable that contains benchmark routines
  34 // (The name of the variable (benchmark_procs) is the name of the spu executable.)
  35 extern spe_program_handle_t benchmark_procs;
  36
  37 static gc_proc_id_t gcp_benchmark_udelay = GCP_UNKNOWN_PROC;
  38
  39 #define BENCHMARK_PUT           0x1
  40 #define BENCHMARK_GET           0x2
  41 #define BENCHMARK_GET_PUT       (BENCHMARK_PUT|BENCHMARK_GET)
  42
  43
  44 #if 0
  45 static bool
  46 power_of_2_p(unsigned long x)
  47 {
  48   int nbits = sizeof(x) * 8;
  49   for (int i = 0; i < nbits; i++)
  50     if (x == (1UL << i))
  51       return true;
  52
  53   return false;
  54 }
  55 #endif
  56
  57 static void
  58 init_jd(gc_job_desc *jd, unsigned int usecs,
  59         unsigned char *getbuf, unsigned char *putbuf, size_t buflen,
  60         int getput_mask)
  61 {
  62   jd->proc_id = gcp_benchmark_udelay;
  63   jd->input.nargs = 1;
  64   jd->input.arg[0].u32 = usecs;
  65   jd->output.nargs = 0;
  66
  67   switch(getput_mask & BENCHMARK_GET_PUT){
  68
  69   case BENCHMARK_GET:
  70     jd->eaa.nargs = 1;
  71     jd->eaa.arg[0].direction = GCJD_DMA_GET;
  72     jd->eaa.arg[0].ea_addr = ptr_to_ea(getbuf);
  73     jd->eaa.arg[0].get_size = buflen;
  74     break;
  75
  76   case BENCHMARK_PUT:
  77     jd->eaa.nargs = 1;
  78     jd->eaa.arg[0].direction = GCJD_DMA_PUT;
  79     jd->eaa.arg[0].ea_addr = ptr_to_ea(putbuf);
  80     jd->eaa.arg[0].put_size = buflen;
  81     break;
  82
  83   case BENCHMARK_GET_PUT:
  84     jd->eaa.nargs = 2;
  85     jd->eaa.arg[0].direction = GCJD_DMA_GET;
  86     jd->eaa.arg[0].ea_addr = ptr_to_ea(getbuf);
  87     jd->eaa.arg[0].get_size = buflen;
  88     jd->eaa.arg[1].direction = GCJD_DMA_PUT;
  89     jd->eaa.arg[1].ea_addr = ptr_to_ea(putbuf);
  90     jd->eaa.arg[1].put_size = buflen;
  91     break;
  92   }
  93 }
  94
  95 static void
  96 run_test(unsigned int nspes, unsigned int usecs, unsigned int dma_size,
  97          int getput_mask, int njobs_at_once)
  98 {
  99   int NJDS = njobs_at_once;
 100   gc_job_desc *all_jds[NJDS];
 101   bool done[NJDS];
 102
 103   static const unsigned int BUFSIZE = (32 << 10) * NJDS;
 104   unsigned char *getbuf = new unsigned char[BUFSIZE];
 105   boost::scoped_array<unsigned char> _getbuf(getbuf);
 106   unsigned char *putbuf = new unsigned char[BUFSIZE];
 107   boost::scoped_array<unsigned char> _putbuf(putbuf);
 108   int gbi = 0;
 109
 110   // touch all pages to force allocation now
 111   for (unsigned int i = 0; i < BUFSIZE; i += 4096){
 112     getbuf[i] = 0;
 113     putbuf[i] = 0;
 114   }
 115
 116   gc_jm_options opts;
 117   opts.program_handle = gc_program_handle_from_address(&benchmark_procs);
 118   opts.nspes = nspes;
 119   //opts.enable_logging = true;
 120   //opts.log2_nlog_entries = 13;
 121   gc_job_manager_sptr mgr = gc_make_job_manager(&opts);
 122
 123   if ((gcp_benchmark_udelay = mgr->lookup_proc("benchmark_udelay")) == GCP_UNKNOWN_PROC){
 124     fprintf(stderr, "lookup_proc: failed to find \"benchmark_udelay\"\n");
 125     return;
 126   }
 127
 128   // allocate and init all job descriptors
 129   for (int i = 0; i < NJDS; i++){
 130     if (gbi + dma_size > BUFSIZE)
 131       gbi = 0;
 132
 133     all_jds[i] = mgr->alloc_job_desc();
 134     if (all_jds[i] == 0){
 135       fprintf(stderr, "alloc_job_desc() returned 0\n");
 136       return;
 137     }
 138     init_jd(all_jds[i], usecs, &getbuf[gbi], &putbuf[gbi], dma_size, getput_mask);
 139     gbi += dma_size;
 140   }
 141
 142   int niter = 100000;
 143   omni_time t_start = omni_time::time();
 144
 145   for (int iter = 0; iter < niter; iter++){
 146
 147     // submit the jobs
 148     for (int i = 0; i < NJDS; i++){
 149       if (!mgr->submit_job(all_jds[i])){
 150         printf("submit_job(jds[%d]) failed, status = %d\n",
 151                i, all_jds[i]->status);
 152       }
 153     }
 154
 155     int n = mgr->wait_jobs(NJDS, all_jds, done, GC_WAIT_ALL);
 156     if (n < 0){
 157       fprintf(stderr, "mgr->wait_jobs failed\n");
 158       break;
 159     }
 160     if (n != NJDS){
 161       fprintf(stderr, "mgr->wait_jobs returned short count.  Expected %d, got %d\n",
 162               NJDS, n);
 163     }
 164   }
 165
 166   // stop timing
 167   omni_time t_stop = omni_time::time();
 168   double delta = (t_stop - t_start).double_time();
 169   printf("nspes: %2d  udelay: %4d  elapsed_time: %7.3f  dma_size: %5d  dma_throughput: %7.3e  round_trip: %gus\n",
 170          mgr->nspes(), usecs, delta, dma_size,
 171          (double) NJDS * niter * dma_size / delta * (getput_mask == BENCHMARK_GET_PUT ? 2.0 : 1.0),
 172          delta / niter * 1e6);
 173 }
 174
 175 static void
 176 usage()
 177 {
 178   fprintf(stderr, "usage: benchmark_dma [-p] [-g] [-n <nspes>] [-u <udelay>] [-s <dma_size>] [-N <njobs_at_a_time>]\n");
 179   fprintf(stderr, "  you must specify one or both of -p (put) and -g (get)\n");
 180 }
 181
 182
 183 int
 184 main(int argc, char **argv)
 185 {
 186   unsigned int nspes = 0;
 187   unsigned int usecs = 0;
 188   unsigned int dma_size = 32 << 10;
 189   int njobs_at_once = -1;
 190   int getput_mask = 0;
 191   int ch;
 192
 193   while ((ch = getopt(argc, argv, "n:u:s:pgN:")) != EOF){
 194     switch(ch){
 195     case 'n':
 196       nspes = strtol(optarg, 0, 0);
 197       break;
 198
 199     case 'u':
 200       usecs = strtol(optarg, 0, 0);
 201       break;
 202
 203     case 'N':
 204       njobs_at_once = strtol(optarg, 0, 0);
 205       break;
 206
 207     case 's':
 208       dma_size = strtol(optarg, 0, 0);
 209       if (dma_size == 0){
 210         fprintf(stderr, "-s <dma_size> must be > 0\n");
 211         return 1;
 212       }
 213       break;
 214
 215     case 'p':
 216       getput_mask |= BENCHMARK_PUT;
 217       break;
 218
 219     case 'g':
 220       getput_mask |= BENCHMARK_GET;
 221       break;
 222
 223     case '?':
 224     default:
 225       usage();
 226       return 1;
 227     }
 228   }
 229
 230   if (njobs_at_once < 0)
 231     njobs_at_once = nspes;
 232
 233   if (getput_mask == 0){
 234     usage();
 235     return 1;
 236   }
 237
 238   run_test(nspes, usecs, dma_size, getput_mask, njobs_at_once);
 239   return 0;
 240 }