vvp/reduce.cc

   1 /*
   2  * Copyright (c) 2005-2007 Stephen Williams (steve@icarus.com)
   3  *
   4  *    This source code is free software; you can redistribute it
   5  *    and/or modify it in source code form under the terms of the GNU
   6  *    General Public License as published by the Free Software
   7  *    Foundation; either version 2 of the License, or (at your option)
   8  *    any later version.
   9  *
  10  *    This program is distributed in the hope that it will be useful,
  11  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *    GNU General Public License for more details.
  14  *
  15  *    You should have received a copy of the GNU General Public License
  16  *    along with this program; if not, write to the Free Software
  17  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  18  */
  19 #ifdef HAVE_CVS_IDENT
  20 #ident "$Id: reduce.cc,v 1.4 2006/05/01 20:47:03 steve Exp $"
  21 #endif
  22
  23 # include  "compile.h"
  24 # include  "schedule.h"
  25 # include  <limits.h>
  26 # include  <stdio.h>
  27 # include  <assert.h>
  28 # include  <stdlib.h>
  29 #ifdef HAVE_MALLOC_H
  30 # include  <malloc.h>
  31 #endif
  32
  33 /*
  34  * All the reduction operations take a single vector input and produce
  35  * a scalar result. The vvp_reduce_base class codifies these general
  36  * charactoristics, leaving only the calculation of the result for the
  37  * base class.
  38  */
  39 class vvp_reduce_base : public vvp_net_fun_t {
  40
  41     public:
  42       vvp_reduce_base();
  43       virtual ~vvp_reduce_base();
  44
  45       void recv_vec4(vvp_net_ptr_t prt, const vvp_vector4_t&bit);
  46       void recv_vec4_pv(vvp_net_ptr_t ptr, const vvp_vector4_t&bit,
  47                         unsigned base, unsigned wid, unsigned vwid);
  48
  49       virtual vvp_bit4_t calculate_result() const =0;
  50
  51     protected:
  52       vvp_vector4_t bits_;
  53 };
  54
  55 vvp_reduce_base::vvp_reduce_base()
  56 {
  57 }
  58
  59 vvp_reduce_base::~vvp_reduce_base()
  60 {
  61 }
  62
  63 void vvp_reduce_base::recv_vec4(vvp_net_ptr_t prt, const vvp_vector4_t&bit)
  64 {
  65       bits_ = bit;
  66       vvp_bit4_t res =  calculate_result();
  67       vvp_vector4_t rv (1, res);
  68       vvp_send_vec4(prt.ptr()->out, rv);
  69 }
  70
  71 void vvp_reduce_base::recv_vec4_pv(vvp_net_ptr_t prt, const vvp_vector4_t&bit,
  72                                    unsigned base, unsigned wid, unsigned vwid)
  73 {
  74       if (bits_.size() == 0) {
  75             bits_ = vvp_vector4_t(vwid);
  76       }
  77       assert(bits_.size() == vwid);
  78
  79       assert(bit.size() == wid);
  80       bits_.set_vec(base, bit);
  81       vvp_bit4_t res = calculate_result();
  82       vvp_vector4_t rv (1, res);
  83       vvp_send_vec4(prt.ptr()->out, rv);
  84 }
  85
  86 class vvp_reduce_and  : public vvp_reduce_base {
  87
  88     public:
  89       vvp_reduce_and();
  90       ~vvp_reduce_and();
  91       vvp_bit4_t calculate_result() const;
  92 };
  93
  94 vvp_reduce_and::vvp_reduce_and()
  95 {
  96 }
  97
  98 vvp_reduce_and::~vvp_reduce_and()
  99 {
 100 }
 101
 102 vvp_bit4_t vvp_reduce_and::calculate_result() const
 103 {
 104       vvp_bit4_t res =  BIT4_1;
 105
 106       for (unsigned idx = 0 ;  idx < bits_.size() ;  idx += 1)
 107             res = res & bits_.value(idx);
 108
 109       return res;
 110 }
 111
 112 class vvp_reduce_or  : public vvp_reduce_base {
 113
 114     public:
 115       vvp_reduce_or();
 116       ~vvp_reduce_or();
 117       vvp_bit4_t calculate_result() const;
 118 };
 119
 120 vvp_reduce_or::vvp_reduce_or()
 121 {
 122 }
 123
 124 vvp_reduce_or::~vvp_reduce_or()
 125 {
 126 }
 127
 128 vvp_bit4_t vvp_reduce_or::calculate_result() const
 129 {
 130       vvp_bit4_t res =  BIT4_0;
 131
 132       for (unsigned idx = 0 ;  idx < bits_.size() ;  idx += 1)
 133             res = res | bits_.value(idx);
 134
 135       return res;
 136 }
 137
 138 class vvp_reduce_xor  : public vvp_reduce_base {
 139
 140     public:
 141       vvp_reduce_xor();
 142       ~vvp_reduce_xor();
 143       vvp_bit4_t calculate_result() const;
 144 };
 145
 146 vvp_reduce_xor::vvp_reduce_xor()
 147 {
 148 }
 149
 150 vvp_reduce_xor::~vvp_reduce_xor()
 151 {
 152 }
 153
 154 vvp_bit4_t vvp_reduce_xor::calculate_result() const
 155 {
 156       vvp_bit4_t res =  BIT4_0;
 157
 158       for (unsigned idx = 0 ;  idx < bits_.size() ;  idx += 1)
 159             res = res ^ bits_.value(idx);
 160
 161       return res;
 162 }
 163
 164 class vvp_reduce_nand  : public vvp_reduce_base {
 165
 166     public:
 167       vvp_reduce_nand();
 168       ~vvp_reduce_nand();
 169       vvp_bit4_t calculate_result() const;
 170 };
 171
 172 vvp_reduce_nand::vvp_reduce_nand()
 173 {
 174 }
 175
 176 vvp_reduce_nand::~vvp_reduce_nand()
 177 {
 178 }
 179
 180 vvp_bit4_t vvp_reduce_nand::calculate_result() const
 181 {
 182       vvp_bit4_t res =  BIT4_1;
 183
 184       for (unsigned idx = 0 ;  idx < bits_.size() ;  idx += 1)
 185             res = res & bits_.value(idx);
 186
 187       return ~res;
 188 }
 189
 190 class vvp_reduce_nor  : public vvp_reduce_base {
 191
 192     public:
 193       vvp_reduce_nor();
 194       ~vvp_reduce_nor();
 195       vvp_bit4_t calculate_result() const;
 196 };
 197
 198 vvp_reduce_nor::vvp_reduce_nor()
 199 {
 200 }
 201
 202 vvp_reduce_nor::~vvp_reduce_nor()
 203 {
 204 }
 205
 206 vvp_bit4_t vvp_reduce_nor::calculate_result() const
 207 {
 208       vvp_bit4_t res =  BIT4_0;
 209
 210       for (unsigned idx = 0 ;  idx < bits_.size() ;  idx += 1)
 211             res = res | bits_.value(idx);
 212
 213       return ~res;
 214 }
 215
 216 class vvp_reduce_xnor  : public vvp_reduce_base {
 217
 218     public:
 219       vvp_reduce_xnor();
 220       ~vvp_reduce_xnor();
 221       vvp_bit4_t calculate_result() const;
 222 };
 223
 224 vvp_reduce_xnor::vvp_reduce_xnor()
 225 {
 226 }
 227
 228 vvp_reduce_xnor::~vvp_reduce_xnor()
 229 {
 230 }
 231
 232 vvp_bit4_t vvp_reduce_xnor::calculate_result() const
 233 {
 234       vvp_bit4_t res =  BIT4_0;
 235
 236       for (unsigned idx = 0 ;  idx < bits_.size() ;  idx += 1)
 237             res = res ^ bits_.value(idx);
 238
 239       return ~res;
 240 }
 241
 242 static void make_reduce(char*label, vvp_net_fun_t*red, struct symb_s arg)
 243 {
 244       vvp_net_t*ptr = new vvp_net_t;
 245       ptr->fun = red;
 246
 247       define_functor_symbol(label, ptr);
 248       free(label);
 249
 250       input_connect(ptr, 0, arg.text);
 251 }
 252
 253 void compile_reduce_and(char*label, struct symb_s arg)
 254 {
 255       vvp_reduce_and* reduce = new vvp_reduce_and;
 256       make_reduce(label, reduce, arg);
 257 }
 258
 259 void compile_reduce_or(char*label, struct symb_s arg)
 260 {
 261       vvp_reduce_or* reduce = new vvp_reduce_or;
 262       make_reduce(label, reduce, arg);
 263 }
 264
 265 void compile_reduce_xor(char*label, struct symb_s arg)
 266 {
 267       vvp_reduce_xor* reduce = new vvp_reduce_xor;
 268       make_reduce(label, reduce, arg);
 269 }
 270
 271 void compile_reduce_nand(char*label, struct symb_s arg)
 272 {
 273       vvp_reduce_nand* reduce = new vvp_reduce_nand;
 274       make_reduce(label, reduce, arg);
 275 }
 276
 277 void compile_reduce_nor(char*label, struct symb_s arg)
 278 {
 279       vvp_reduce_nor* reduce = new vvp_reduce_nor;
 280       make_reduce(label, reduce, arg);
 281 }
 282
 283 void compile_reduce_xnor(char*label, struct symb_s arg)
 284 {
 285       vvp_reduce_xnor* reduce = new vvp_reduce_xnor;
 286       make_reduce(label, reduce, arg);
 287 }