Class: RedShift::DelayFlow

Inherits:
Flow show all
Defined in:
lib/redshift/component.rb,
lib/redshift/target/c/flow/delay.rb

Constant Summary

Constants inherited from Flow

Flow::CT_STRUCT_NAME

Instance Attribute Summary collapse

Attributes inherited from Flow

#fname, #formula, #generator, #inspect_str, #strict, #var

Instance Method Summary collapse

Methods inherited from Flow

#become_generatable, #external_constant?, #generate, #inspect, #make_ct_struct, #translate, #translate_link, #wrapper

Constructor Details

#initialize(v, f, delay_by) ⇒ DelayFlow

Returns a new instance of DelayFlow.



119
120
121
122
 
# File 'lib/redshift/component.rb', line 119

def initialize v, f, delay_by
  super(v, f)
  @delay_by = delay_by
end

Instance Attribute Details

#delay_by ⇒ Object (readonly)

Returns the value of attribute delay_by.



118
119
120
 
# File 'lib/redshift/component.rb', line 118

def delay_by
  @delay_by
end

Instance Method Details

#make_generator(cl, state) ⇒ Object 



2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
 
# File 'lib/redshift/target/c/flow/delay.rb', line 2

def make_generator cl, state
  delay_by = @delay_by
  @fname = "flow_#{CGenerator.make_c_name cl.name}_#{var}_#{state}"
  @inspect_str =
    "#{cl.name}:#{state}: " +
    "#{var} = #{formula} [delay: #{delay_by}]"

  @generator = proc do
    sl = cl.shadow_library
    ssn = cl.shadow_struct_name
    cont_state_ssn = cl.cont_state_class.shadow_struct_name
    
    require "redshift/target/c/flow/buffer"
    RedShift.library.define_buffer

    bufname     = "#{var}_buffer_data"
    delayname   = "#{var}_delay"
    tsname      = "#{var}_time_step"
    
    cl.class_eval do
      shadow_attr_accessor bufname    => "RSBuffer  #{bufname}"
      shadow_attr_accessor delayname  => "double    #{delayname}"
        # delay should be set only using the expr designated in :by => "expr"
      shadow_attr          tsname     => "double    #{tsname}"
    
      after_commit do
        alias_method "__#{bufname}=", "#{bufname}="
        define_method "#{bufname}=" do |val|
          send("__#{bufname}=", val)
          d = world.time_step * (val.size / 4)
          send("#{delayname}=", d) # keep cached delay consistent
        end
      end
      private :"#{delayname}="
    end
    
    sl.init_library_function.body \
      "s_init_flow(#{fname}, #{fname.inspect}, #{inspect_str.inspect}, NONALGEBRAIC);"

    include_file, source_file = sl.add_file fname
    
    # We need the struct
    source_file.include(cl.shadow_library_include_file)
    
    flow = self
    var_name = @var
    source_file.define(fname).instance_eval do
      arguments "ComponentShadow *comp_shdw"
      scope :extern
      declare :shadow => %{
        struct #{ssn} *shadow;
        struct #{cont_state_ssn} *cont_state;
        
        ContVar   *var;
        double    *ptr;
        long      len, offset, steps;
        double    delay, fill;
      }
      setup :shadow => %{
        shadow = (#{ssn} *)comp_shdw;
        cont_state = (struct #{cont_state_ssn} *)shadow->cont_state;
        var = &cont_state->#{var_name};
      }
      setup :rk_level => %{
        shadow->world->rk_level--;
      } # has to happen before referenced alg flows are called in other setups

      setup :delay => 
        begin
          "delay = #{Float(delay_by)}"
        rescue ArgumentError
          flow.translate(self, "delay", cl, 0, delay_by)
        end
      
      source_file.include World.shadow_library_include_file

      # Note: cases 1,2 must proceed to allow alg deps to be computed,
      # since their values are used later.
      body %{
        switch (shadow->world->rk_level) {
        case 0:
          ptr = shadow->#{bufname}.ptr;
          offset = shadow->#{bufname}.offset;
          
          if (shadow->world->time_step != shadow->#{tsname}) {
            if (shadow->#{tsname} == 0.0)
              shadow->#{tsname} = shadow->world->time_step;
            else
              rs_raise(#{declare_class RedShiftError}, shadow->self,
              "Delay flow doesn't support changing time_step yet"); // ##
          }
          
          if (ptr && delay == shadow->#{delayname}) {
            len = shadow->#{bufname}.len;
            if (offset < 0 || offset > len - 4) {
              rs_raise(#{declare_class RedShiftError}, shadow->self,
              "Offset out of bounds: %d not in 0..%d!", offset, len - 4);
            }
          }
          else {
            steps = floor(delay / shadow->world->time_step + 0.5);
            if (steps <= 0) {
              rs_raise(#{declare_class RedShiftError}, shadow->self,
              "Delay too small: %f.", delay);
            }
            len = steps*4;

            if (!ptr) {
              #{flow.translate(self, "fill", cl, 0).join("
              ")};

              rs_buffer_init(&shadow->#{bufname}, len, fill);
            }
            else { // # delay != shadow->#{delayname}
              rs_buffer_resize(&shadow->#{bufname}, len);
            }
            
            shadow->#{delayname} = delay;
            ptr = shadow->#{bufname}.ptr;
            offset = shadow->#{bufname}.offset;
          }
          
          var->value[0] = ptr[offset];
          var->value[1] = ptr[offset + 1];
          var->value[2] = ptr[offset + 2];
          var->value[3] = ptr[offset + 3];
          
          #{flow.translate(self, "ptr[offset]", cl, 0).join("
          ")};
          break;
          
        case 1:
        case 2:
          break;

        case 3:
          ptr = shadow->#{bufname}.ptr;
          len = shadow->#{bufname}.len;
          offset = shadow->#{bufname}.offset;

          #{flow.translate(self, "ptr[offset+1]", cl, 1).join("
          ")};
          #{flow.translate(self, "ptr[offset+2]", cl, 2).join("
          ")};
          #{flow.translate(self, "ptr[offset+3]", cl, 3).join("
          ")};

          offset = (offset + 4) % len;
          var->value[0] = ptr[offset];
          shadow->#{bufname}.offset = offset;
          break;
          
        default:
          rb_raise(#{declare_class RuntimeError},
            "Bad rk_level, %ld!", shadow->world->rk_level);
        }

        shadow->world->rk_level++;
        var->rk_level = shadow->world->rk_level;
      }
    end
  end
end