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

#formula, #strict, #var

Instance Method Summary collapse

Methods inherited from Flow

#external_constant?, #make_ct_struct, #translate, #translate_link

Constructor Details

#initialize(v, f, delay_by) ⇒ DelayFlow

Returns a new instance of DelayFlow.



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

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.



115
116
117
 
# File 'lib/redshift/component.rb', line 115

def delay_by
  @delay_by
end

Instance Method Details

#flow_wrapper(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
 
# File 'lib/redshift/target/c/flow/delay.rb', line 2

def flow_wrapper cl, state
  var_name = @var
  flow = self
  flow_name = "flow_#{CGenerator.make_c_name cl.name}_#{var_name}_#{state}"
  delay_by = @delay_by
  
  Component::FlowWrapper.make_subclass flow_name do
    @inspect_str =
      "#{cl.name}:#{state}: " +
      "#{var_name} = #{flow.formula} [delay: #{delay_by}]"

    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_name}_buffer_data"
    delayname   = "#{var_name}_delay"
    tsname      = "#{var_name}_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
    
    # We need the struct
    shadow_library_source_file.include(cl.shadow_library_include_file)
    
    shadow_library_source_file.define(flow_name).instance_eval do
      arguments "ComponentShadow *comp_shdw"
      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 = (#{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", 0, cl, delay_by)
        end
      
      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", 0, cl).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]", 0, cl).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]", 1, cl).join("
          ")};
          #{flow.translate(self, "ptr[offset+2]", 2, cl).join("
          ")};
          #{flow.translate(self, "ptr[offset+3]", 3, cl).join("
          ")};

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

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

    define_c_method :calc_function_pointer do
      body "shadow->flow = &#{flow_name}"
    end
  end
end