redshift 1.3.15

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

@@ -0,0 +1,203 @@
+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}"
+    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"
+      offsetname  = "#{var_name}_buffer_offset"
+      delayname   = "#{var_name}_delay"
+      tsname      = "#{var_name}_time_step"
+      
+      cl.class_eval do
+        shadow_attr_accessor bufname    => "Buffer  #{bufname}"
+        shadow_attr_accessor offsetname => "long    #{offsetname}"
+        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      i, 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->#{offsetname};
+            
+            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("
+                ")};
+
+                ptr = ALLOC_N(double, len);
+                shadow->#{bufname}.ptr = ptr;
+                shadow->#{bufname}.len = len;
+                shadow->#{offsetname} = 0;
+                shadow->#{delayname} = delay;
+
+                for (i=0; i<len; i++) {
+                  ptr[i] = fill;
+                }
+              }
+              else { // # delay != shadow->#{delayname}
+                long old_len = shadow->#{bufname}.len;
+                double *dst, *src;
+
+                if (delay < shadow->#{delayname}) {
+                  if (offset < len) {
+                    dst = ptr + offset;
+                    src = ptr + offset + old_len - len;
+                  }
+                  else {
+                    dst = ptr;
+                    src = ptr + offset - len;
+                    offset = 0;
+                  }
+                  memmove(dst, src, (len - offset) * sizeof(double));
+                  REALLOC_N(ptr, double, len);
+                  // ## maybe better: don't release space, just use less of it
+                }
+                else { // # delay > shadow->#{delayname}
+                  REALLOC_N(ptr, double, len);
+
+                  fill = ptr[offset];
+                  dst = ptr + offset + len - old_len;
+                  src = ptr + offset;
+                  memmove(dst, src, (old_len - offset) * sizeof(double));
+
+                  for (i = 0; i < len - old_len; i++) {
+                    ptr[offset + i] = fill;
+                  }
+                }
+                
+                shadow->#{bufname}.ptr = ptr;
+                shadow->#{bufname}.len = len;
+                shadow->#{offsetname} = offset;
+                shadow->#{delayname} = delay;
+              }
+            }
+            
+            offset = (offset + 4) % len;
+            shadow->#{offsetname} = 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->#{offsetname};
+
+            #{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("
+            ")};
+
+            var->value_0 = ptr[(offset + 4) % len];
+            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
+end; end

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

@@ -0,0 +1,101 @@
+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}'"
+
+      ssn = cl.shadow_struct.name
+      cont_state_ssn = cl.cont_state_class.shadow_struct.name
+      
+      # We need the struct
+      shadow_library_source_file.include(cl.shadow_library_include_file)
+      
+      init_rhs_name  = "#{var_name}_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
+        arguments "ComponentShadow *comp_shdw"
+        declare :shadow => %{
+          struct #{ssn} *shadow;
+          struct #{cont_state_ssn} *cont_state;
+          ContVar  *var;
+          double    antiddt, *scratch;
+          double    time_step;
+        }
+        setup :shadow => %{
+          shadow = (#{ssn} *)comp_shdw;
+          cont_state = (#{cont_state_ssn} *)shadow->cont_state;
+          var = &cont_state->#{var_name};
+          scratch = &shadow->#{init_rhs_name};
+          time_step = shadow->world->time_step;
+        }
+        setup :rk_level => %{
+          shadow->world->rk_level--;
+        } # has to happen before referenced alg flows are called in other setups
+        if feedback ## possible to unite these cases somehow?
+          body %{
+            switch (shadow->world->rk_level) {
+            case 0:
+              #{flow.translate(self, "antiddt", 0, cl).join("
+              ")};
+              var->value_0 = var->value_1 =
+              var->value_2 = var->value_3 =
+              (antiddt - *scratch) / time_step;
+              *scratch = antiddt;
+            }
+            shadow->world->rk_level++;
+            var->rk_level = shadow->world->rk_level;
+          }
+        else
+          body %{
+            switch (shadow->world->rk_level) {
+            case 0:
+              #{flow.translate(self, "antiddt", 0, cl).join("
+              ")};
+              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);
+              *scratch = antiddt;
+              break;
+
+            case 2:
+              #{flow.translate(self, "antiddt", 2, cl).join("
+              ")};
+              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);
+              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
+      end
+
+      define_c_method :calc_function_pointer do
+        body "shadow->flow = &#{flow_name}"
+      end
+    end
+  end
+
+end; end

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

@@ -0,0 +1,67 @@
+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}"
+
+      ssn = cl.shadow_struct.name
+      cont_state_ssn = cl.cont_state_class.shadow_struct.name
+      
+      # 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    ddt_#{var_name};
+          double    time_step;
+        }
+        setup :first => %{
+          if (comp_shdw->world->rk_level == 2 ||
+              comp_shdw->world->rk_level == 3)
+            return;
+        } ## 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;
+          var = &cont_state->#{var_name};
+          time_step = shadow->world->time_step;
+        } # return is necessary--else shadow, cont_state, var are uninitialized
+        setup :rk_level => %{
+          shadow->world->rk_level--;
+        } # has to happen before referenced alg flows are called in other setups
+        body %{
+          switch (shadow->world->rk_level) {
+          case 0:
+            #{flow.translate(self, "ddt_#{var_name}", 0, cl).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->rk_level = 3;
+            break;
+          
+          case 3:
+            var->value_0 = var->value_3;
+            var->rk_level = 4;
+            break;
+          }
+
+          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/expr.rb

@@ -0,0 +1,113 @@
+module RedShift; class CexprGuard
+
+  def initialize f
+    super nil, f
+  end
+  
+  @@serial = 0
+  
+  # +cl+ is the component class
+  ## maybe all these methods should just be called wrapper?
+  def guard_wrapper cl
+    guard = self
+    cl_cname = CGenerator.make_c_name cl.name
+    g_cname = "Guard_#{@@serial}"; @@serial += 1
+    guard_name = "guard_#{cl_cname}_#{g_cname}"
+    
+    Component::GuardWrapper.make_subclass guard_name do
+      @inspect_str = "#{cl.name}: #{guard.formula}"
+ 
+      ssn = cl.shadow_struct.name
+      cont_state_ssn = cl.cont_state_class.shadow_struct.name
+      
+      # We need the struct
+      shadow_library_source_file.include(cl.shadow_library_include_file)
+      
+      strict = false
+      
+      shadow_library_source_file.define(guard_name).instance_eval do
+        arguments "ComponentShadow *comp_shdw"
+        return_type "int"
+        declare :shadow => %{
+          struct #{ssn} *shadow;
+          struct #{cont_state_ssn} *cont_state;
+          ContVar  *var;
+        }
+        setup :shadow => %{
+          shadow = (#{ssn} *)comp_shdw;
+          cont_state = (#{cont_state_ssn} *)shadow->cont_state;
+        }
+        declare :result => "int result"
+        translation = guard.translate(self, "result", 0, cl) {|s| strict = s}
+        body %{
+          #{translation.join("
+          ")};
+          return result;
+        }
+      end
+      
+      @strict = strict
+      ## should set guard.strict = strict too?
+      
+      define_c_method :calc_function_pointer do
+        body "shadow->guard = &#{guard_name}"
+      end
+    end
+  end
+end; end
+
+module RedShift; class Expr
+  attr_reader :type
+  
+  def initialize f, type = "double"
+    super nil, f
+    @type = type
+  end
+  
+  @@serial = 0
+  
+  # +cl+ is the component class
+  def wrapper(cl)
+    expr = self
+    cl_cname = CGenerator.make_c_name cl.name
+    ex_cname = "Expr_#{@@serial}"; @@serial += 1
+    expr_name = "expr_#{cl_cname}_#{ex_cname}"
+    
+    Component::ExprWrapper.make_subclass expr_name do
+      @inspect_str = "#{cl.name}: #{expr.formula}"
+
+      ssn = cl.shadow_struct.name
+      cont_state_ssn = cl.cont_state_class.shadow_struct.name
+      
+      # We need the struct
+      shadow_library_source_file.include(cl.shadow_library_include_file)
+      
+      shadow_library_source_file.define(expr_name).instance_eval do
+        arguments "ComponentShadow *comp_shdw"
+        return_type expr.type
+        declare :shadow => %{
+          struct #{ssn} *shadow;
+          struct #{cont_state_ssn} *cont_state;
+          ContVar  *var;
+        }
+        setup :shadow => %{
+          shadow = (#{ssn} *)comp_shdw;
+          cont_state = (#{cont_state_ssn} *)shadow->cont_state;
+        }
+        declare :result => "#{expr.type} result"
+        translation = expr.translate(self, "result", 0, cl)
+        body %{
+          #{translation.join("
+          ")};
+          return result;
+        }
+      end
+      
+      define_c_method :calc_function_pointer do
+        body "shadow->expr = &#{expr_name}"
+      end
+    end
+  end
+end; end
+
+module RedShift; class ResetExpr < Expr; end; end