redshift 1.3.21 → 1.3.22

data/lib/redshift/target/c/flow-gen.rb

@@ -8,7 +8,7 @@ module RedShift
 end
 
 module RedShift; class Flow
-  def translate flow_fn, result_var, rk_level, cl, orig_formula = nil
+  def translate flow_fn, result_var, cl, rk_level = nil, orig_formula = nil
     translation = {}
     setup = []    ## should use accumulator
     
@@ -43,7 +43,7 @@ module RedShift; class Flow
 
               ct_struct = make_ct_struct(flow_fn, cl)
 
-              link_type_ssn = link_type.shadow_struct.name
+              link_type_ssn = link_type.shadow_struct_name
               ct_struct.declare link_cname => "#{link_type_ssn} *#{link_cname}"
               flow_fn.setup  link_cname => "ct.#{link_cname} = shadow->#{link}"
             end
@@ -77,7 +77,8 @@ module RedShift; class Flow
               }
             }
             # The d_tick assignment is explained in component-gen.rb.
-            setup << "#{var_cname} = #{cont_var}.value_#{rk_level};"
+            rk = rk_level || "shadow->world->rk_level"
+            setup << "#{var_cname} = #{cont_var}.value[#{rk}];"
           
           elsif (kind = cl.input_variables[varsym])
             # x ==> var_x
@@ -157,7 +158,7 @@ module RedShift; class Flow
     else
       ct_struct = sf.declare_struct(CT_STRUCT_NAME)
 
-      ct_struct.declare :shadow => "#{cl.shadow_struct.name} *shadow"
+      ct_struct.declare :shadow => "#{cl.shadow_struct_name} *shadow"
 
       flow_fn.declare :ct => "#{CT_STRUCT_NAME} ct"
       flow_fn.setup   :ct_shadow => "ct.shadow = shadow"
@@ -166,7 +167,7 @@ module RedShift; class Flow
     ct_struct
   end
   
-  # l.x  ==>  get_l__x()->value_n
+  # l.x  ==>  get_l__x()->value[n]
   def translate_link(link, var, translation, flow_fn, cl, expr, rk_level)
     link_type, link_strictness = cl.link_variables[link.intern]
     raise(NameError, "No such link, #{link}") unless link_type
@@ -208,7 +209,7 @@ module RedShift; class Flow
     end
 
     if var_type == :continuous
-      link_cs_ssn = link_type.cont_state_class.shadow_struct.name
+      link_cs_ssn = link_type.cont_state_class.shadow_struct_name
       link_cs_cname = "link_cs_#{link}"
       ct_struct.declare link_cs_cname => "#{link_cs_ssn} *#{link_cs_cname}"
     end
@@ -218,7 +219,7 @@ module RedShift; class Flow
 
       unless translation[link]
         translation[link] = link_cname
-        link_type_ssn = link_type.shadow_struct.name
+        link_type_ssn = link_type.shadow_struct_name
         ct_struct.declare link_cname => "#{link_type_ssn} *#{link_cname}"
         flow_fn.setup     link_cname => "ct.#{link_cname} = shadow->#{link}"
       end ## same as below
@@ -256,7 +257,8 @@ module RedShift; class Flow
         }
       } ## algebraic test is same as above
 
-      translation[expr] = "#{get_var_cname}(&ct)->value_#{rk_level}"
+      rk = rk_level || "shadow->world->rk_level"
+      translation[expr] = "#{get_var_cname}(&ct)->value[#{rk}]"
     
     when :constant
       sf.declare get_var_cname => %{
@@ -270,7 +272,7 @@ module RedShift; class Flow
       translation[expr] = "#{get_var_cname}(&ct)"
     
     when :link
-      link_link_type_ssn = link_link_type.shadow_struct.name
+      link_link_type_ssn = link_link_type.shadow_struct_name
       sf.declare get_var_cname => %{
         inline static #{link_link_type_ssn} *#{get_var_cname}(#{CT_STRUCT_NAME} *ct) {
           if (!ct->#{link_cname})

data/lib/redshift/target/c/flow/algebraic.rb

@@ -1,20 +1,27 @@
 module RedShift; class AlgebraicFlow
-  def flow_wrapper cl, state
-    var_name = @var
-    flow = self
-    flow_name = "flow_#{CGenerator.make_c_name cl.name}_#{var_name}_#{state}"
+  def make_generator cl, state
+    @fname = "flow_#{CGenerator.make_c_name cl.name}_#{var}_#{state}"
+    @inspect_str = "#{cl.name}:#{state}: #{var} = #{formula}"
     
-    Component::FlowWrapper.make_subclass flow_name do
-      @inspect_str = "#{cl.name}:#{state}: #{var_name} = #{flow.formula}"
+    @generator = proc do
+      sl = cl.shadow_library
+      ssn = cl.shadow_struct_name
+      cont_state_ssn = cl.cont_state_class.shadow_struct_name
+      
+      ## use an accumulator for these
+      sl.init_library_function.body \
+        "s_init_flow(#{fname}, #{fname.inspect}, #{inspect_str.inspect}, ALGEBRAIC);"
 
-      ssn = cl.shadow_struct.name
-      cont_state_ssn = cl.cont_state_class.shadow_struct.name
+      include_file, source_file = sl.add_file fname
       
       # We need the struct
-      shadow_library_source_file.include(cl.shadow_library_include_file)
+      source_file.include(cl.shadow_library_include_file)
       
-      shadow_library_source_file.define(flow_name).instance_eval do
+      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;
@@ -28,45 +35,31 @@ module RedShift; class AlgebraicFlow
         
         setup :shadow => %{
           shadow = (#{ssn} *)comp_shdw;
-          cont_state = (#{cont_state_ssn} *)shadow->cont_state;
+          cont_state = (struct #{cont_state_ssn} *)shadow->cont_state;
           var = &cont_state->#{var_name};
           assert(var->algebraic);
-          if (shadow->world->alg_nest > 100) {
+          if (shadow->world->alg_nest > shadow->world->alg_depth_limit) {
             shadow->world->alg_nest = 0;
             rs_raise(#{exc}, shadow->self, #{msg.inspect});
           }
           shadow->world->alg_nest++;
         }
-        ## 100 not always enough, so could increase limit exponentially,
-        ## and look in subsequent iterations for repeats of this [var, obj].
         
-        ## optimization: it might be possible to translate once and
-        ## use gsub to make each of the four versions, or use a template.
         body %{
+          #{flow.translate(self,
+              "var->value[shadow->world->rk_level]", cl) {|strict|
+            flow.instance_eval {@strict = strict}
+          }.join("
+          ")};
+
           switch (shadow->world->rk_level) {
           case 0:
-            #{flow.translate(self, "var->value_0", 0, cl).join("
-            ")};
             var->d_tick = shadow->world->d_tick;
             break;
             
           case 1:
-            #{flow.translate(self, "var->value_1", 1, cl).join("
-            ")};
-            var->rk_level = shadow->world->rk_level;
-            break;
-            
           case 2:
-            #{flow.translate(self, "var->value_2", 2, cl).join("
-            ")};
-            var->rk_level = shadow->world->rk_level;
-            break;
-            
           case 3:
-            #{flow.translate(self, "var->value_3", 3, cl){|strict|
-              flow.instance_eval {@strict = strict}
-            }.join("
-            ")};
             var->rk_level = shadow->world->rk_level;
             break;
             
@@ -77,12 +70,14 @@ module RedShift; class AlgebraicFlow
           
           shadow->world->alg_nest--;
         }
-      end # Case 0 applies during discrete update.
-          # alg flows are lazy
-
-      define_c_method :calc_function_pointer do
-        body "shadow->flow = &#{flow_name}", "shadow->algebraic = 1"
       end
+      # Case 0 applies during discrete update.
+      # Alg flows are lazy.
+      # Note that @strict does not need to propagate to wrapper
+      # (as it does in CexprGuard) since checking is done statically
+      # in Component.define_flow.
     end
+    
+    return self
   end
 end; end

data/lib/redshift/target/c/flow/delay.rb

@@ -1,24 +1,22 @@
 module RedShift; class DelayFlow
-  def flow_wrapper cl, state
-    var_name = @var
-    flow = self
-    flow_name = "flow_#{CGenerator.make_c_name cl.name}_#{var_name}_#{state}"
+  def make_generator cl, state
     delay_by = @delay_by
-    
-    Component::FlowWrapper.make_subclass flow_name do
-      @inspect_str =
-        "#{cl.name}:#{state}: " +
-        "#{var_name} = #{flow.formula} [delay: #{delay_by}]"
+    @fname = "flow_#{CGenerator.make_c_name cl.name}_#{var}_#{state}"
+    @inspect_str =
+      "#{cl.name}:#{state}: " +
+      "#{var} = #{formula} [delay: #{delay_by}]"
 
-      ssn = cl.shadow_struct.name
-      cont_state_ssn = cl.cont_state_class.shadow_struct.name
+    @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_name}_buffer_data"
-      delayname   = "#{var_name}_delay"
-      tsname      = "#{var_name}_time_step"
+      bufname     = "#{var}_buffer_data"
+      delayname   = "#{var}_delay"
+      tsname      = "#{var}_time_step"
       
       cl.class_eval do
         shadow_attr_accessor bufname    => "RSBuffer  #{bufname}"
@@ -37,11 +35,19 @@ module RedShift; class DelayFlow
         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
-      shadow_library_source_file.include(cl.shadow_library_include_file)
+      source_file.include(cl.shadow_library_include_file)
       
-      shadow_library_source_file.define(flow_name).instance_eval do
+      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;
@@ -53,7 +59,7 @@ module RedShift; class DelayFlow
         }
         setup :shadow => %{
           shadow = (#{ssn} *)comp_shdw;
-          cont_state = (#{cont_state_ssn} *)shadow->cont_state;
+          cont_state = (struct #{cont_state_ssn} *)shadow->cont_state;
           var = &cont_state->#{var_name};
         }
         setup :rk_level => %{
@@ -64,7 +70,7 @@ module RedShift; class DelayFlow
           begin
             "delay = #{Float(delay_by)}"
           rescue ArgumentError
-            flow.translate(self, "delay", 0, cl, delay_by)
+            flow.translate(self, "delay", cl, 0, delay_by)
           end
         
         include World.shadow_library_include_file
@@ -101,7 +107,7 @@ module RedShift; class DelayFlow
               len = steps*4;
 
               if (!ptr) {
-                #{flow.translate(self, "fill", 0, cl).join("
+                #{flow.translate(self, "fill", cl, 0).join("
                 ")};
 
                 rs_buffer_init(&shadow->#{bufname}, len, fill);
@@ -115,12 +121,12 @@ module RedShift; class DelayFlow
               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];
+            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("
+            #{flow.translate(self, "ptr[offset]", cl, 0).join("
             ")};
             break;
             
@@ -133,15 +139,15 @@ module RedShift; class DelayFlow
             len = shadow->#{bufname}.len;
             offset = shadow->#{bufname}.offset;
 
-            #{flow.translate(self, "ptr[offset+1]", 1, cl).join("
+            #{flow.translate(self, "ptr[offset+1]", cl, 1).join("
             ")};
-            #{flow.translate(self, "ptr[offset+2]", 2, cl).join("
+            #{flow.translate(self, "ptr[offset+2]", cl, 2).join("
             ")};
-            #{flow.translate(self, "ptr[offset+3]", 3, cl).join("
+            #{flow.translate(self, "ptr[offset+3]", cl, 3).join("
             ")};
 
             offset = (offset + 4) % len;
-            var->value_0 = ptr[offset];
+            var->value[0] = ptr[offset];
             shadow->#{bufname}.offset = offset;
             break;
             
@@ -154,10 +160,6 @@ module RedShift; class DelayFlow
           var->rk_level = shadow->world->rk_level;
         }
       end
-
-      define_c_method :calc_function_pointer do
-        body "shadow->flow = &#{flow_name}"
-      end
     end
   end
 end; end

data/lib/redshift/target/c/flow/derivative.rb

@@ -1,26 +1,32 @@
 module RedShift; class DerivativeFlow
-  def flow_wrapper cl, state
-    var_name = @var
-    flow = self
-    flow_name = "flow_#{CGenerator.make_c_name cl.name}_#{var_name}_#{state}"
-    feedback = @feedback
-    
-    Component::FlowWrapper.make_subclass flow_name do
-      @inspect_str = "#{cl.name}:#{state}: #{var_name} = #{flow.formula}'"
+  def make_generator cl, state
+    @fname = "flow_#{CGenerator.make_c_name cl.name}_#{var}_#{state}"
+    @inspect_str = "#{cl.name}:#{state}: #{var} = #{formula}"
 
-      ssn = cl.shadow_struct.name
-      cont_state_ssn = cl.cont_state_class.shadow_struct.name
+    @generator = proc do
+      sl = cl.shadow_library
+      ssn = cl.shadow_struct_name
+      cont_state_ssn = cl.cont_state_class.shadow_struct_name
+
+      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
-      shadow_library_source_file.include(cl.shadow_library_include_file)
+      source_file.include(cl.shadow_library_include_file)
       
-      init_rhs_name  = "#{var_name}_init_rhs"
+      init_rhs_name = "#{var}_init_rhs"
       cl.class_eval do
         shadow_attr_accessor init_rhs_name => "double #{init_rhs_name}"
       end
       
-      shadow_library_source_file.define(flow_name).instance_eval do
+      flow = self
+      var_name = @var
+      feedback = @feedback
+      source_file.define(fname).instance_eval do
         arguments "ComponentShadow *comp_shdw"
+        scope :extern
         declare :shadow => %{
           struct #{ssn} *shadow;
           struct #{cont_state_ssn} *cont_state;
@@ -30,7 +36,7 @@ module RedShift; class DerivativeFlow
         }
         setup :shadow => %{
           shadow = (#{ssn} *)comp_shdw;
-          cont_state = (#{cont_state_ssn} *)shadow->cont_state;
+          cont_state = (struct #{cont_state_ssn} *)shadow->cont_state;
           var = &cont_state->#{var_name};
           scratch = &shadow->#{init_rhs_name};
           time_step = shadow->world->time_step;
@@ -42,10 +48,10 @@ module RedShift; class DerivativeFlow
           body %{
             switch (shadow->world->rk_level) {
             case 0:
-              #{flow.translate(self, "antiddt", 0, cl).join("
+              #{flow.translate(self, "antiddt", cl, 0).join("
               ")};
-              var->value_0 = var->value_1 =
-              var->value_2 = var->value_3 =
+              var->value[0] = var->value[1] =
+              var->value[2] = var->value[3] =
               (antiddt - *scratch) / time_step;
               *scratch = antiddt;
             }
@@ -54,31 +60,26 @@ module RedShift; class DerivativeFlow
           }
         else
           body %{
+            #{flow.translate(self, "antiddt", cl).join("
+            ")};
+
             switch (shadow->world->rk_level) {
             case 0:
-              #{flow.translate(self, "antiddt", 0, cl).join("
-              ")};
-              var->value_1 = var->value_0;
+              var->value[1] = var->value[0];
               *scratch = antiddt;
               break;
 
             case 1:
-              #{flow.translate(self, "antiddt", 1, cl).join("
-              ")};
-              var->value_2 = (antiddt - *scratch) / (time_step/2);
+              var->value[2] = (antiddt - *scratch) / (time_step/2);
               *scratch = antiddt;
               break;
 
             case 2:
-              #{flow.translate(self, "antiddt", 2, cl).join("
-              ")};
-              var->value_3 = (antiddt - *scratch) / (time_step/2);
+              var->value[3] = (antiddt - *scratch) / (time_step/2);
               break;
 
             case 3:
-              #{flow.translate(self, "antiddt", 3, cl).join("
-              ")};
-              var->value_0 = (antiddt - *scratch) / (time_step/2);
+              var->value[0] = (antiddt - *scratch) / (time_step/2);
               break;
 
             default:
@@ -91,10 +92,6 @@ module RedShift; class DerivativeFlow
           }
         end
       end
-
-      define_c_method :calc_function_pointer do
-        body "shadow->flow = &#{flow_name}"
-      end
     end
   end
 

data/lib/redshift/target/c/flow/euler.rb

@@ -1,21 +1,26 @@
 module RedShift; class EulerDifferentialFlow
-  def flow_wrapper cl, state
-    var_name = @var
-    flow = self
-    
-    flow_name = "flow_#{CGenerator.make_c_name cl.name}_#{var_name}_#{state}"
-    
-    Component::FlowWrapper.make_subclass flow_name do
-      @inspect_str = "#{cl.name}:#{state}: #{var_name} = #{flow.formula}"
+  def make_generator cl, state
+    @fname = "flow_#{CGenerator.make_c_name cl.name}_#{var}_#{state}"
+    @inspect_str = "#{cl.name}:#{state}: #{var} = #{formula}"
 
-      ssn = cl.shadow_struct.name
-      cont_state_ssn = cl.cont_state_class.shadow_struct.name
+    @generator = proc do
+      sl = cl.shadow_library
+      ssn = cl.shadow_struct_name
+      cont_state_ssn = cl.cont_state_class.shadow_struct_name
+
+      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
-      shadow_library_source_file.include(cl.shadow_library_include_file)
+      source_file.include(cl.shadow_library_include_file)
       
-      shadow_library_source_file.define(flow_name).instance_eval do
+      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;
@@ -30,7 +35,7 @@ module RedShift; class EulerDifferentialFlow
         } ## optimization: in rk_level==4 case, don't need to calc deps
         setup :shadow => %{
           shadow = (#{ssn} *)comp_shdw;
-          cont_state = (#{cont_state_ssn} *)shadow->cont_state;
+          cont_state = (struct #{cont_state_ssn} *)shadow->cont_state;
           var = &cont_state->#{var_name};
           time_step = shadow->world->time_step;
         } # return is necessary--else shadow, cont_state, var are uninitialized
@@ -40,18 +45,18 @@ module RedShift; class EulerDifferentialFlow
         body %{
           switch (shadow->world->rk_level) {
           case 0:
-            #{flow.translate(self, "ddt_#{var_name}", 0, cl).join("
+            #{flow.translate(self, "ddt_#{var_name}", cl, 0).join("
             ")};
 
-            var->value_1 = var->value_2 =
-              var->value_0 + ddt_#{var_name} * time_step/2;
-            var->value_3 =
-              var->value_0 + ddt_#{var_name} * time_step;
+            var->value[1] = var->value[2] =
+              var->value[0] + ddt_#{var_name} * time_step/2;
+            var->value[3] =
+              var->value[0] + ddt_#{var_name} * time_step;
             var->rk_level = 3;
             break;
           
           case 3:
-            var->value_0 = var->value_3;
+            var->value[0] = var->value[3];
             var->rk_level = 4;
             break;
           }
@@ -59,9 +64,6 @@ module RedShift; class EulerDifferentialFlow
           shadow->world->rk_level++;
         }
       end
-      define_c_method :calc_function_pointer do
-        body "shadow->flow = &#{flow_name}"
-      end
     end
   end
 end; end