redshift 1.3.21 → 1.3.22

data/lib/redshift/component.rb

@@ -88,8 +88,11 @@ class Flow    ## rename to equation? formula? put in meta?
   # steps of the discrete update. This can be false only for an AlgebraicFlow
   # which depends on non-strict variables. In the algebraic case, a flow is
   # strict iff the RHS of the eqn. has only strictly continuous variables.
+  # Guards are not flows (except by inheritance); CexprGuard instances may be
+  # non-strict. Reset expressions (Exprs) always evaluate, so strictness does
+  # not apply.
   attr_reader :strict
-  
+
   def initialize v, f
     @var, @formula = v, f
     @strict = true

data/lib/redshift/meta.rb

@@ -109,6 +109,8 @@ class Component
     end
 
     def outgoing_transition_data s
+      raise unless committed?
+      
       ary = []
       all_strict = true
       seen = {}

data/lib/redshift/mixins/zeno-debugger.rb

@@ -28,7 +28,7 @@ class RedShift::World
     attr_accessor :debug_zeno_limit
     
     def initialize
-      @debug_zeno       ||= $REDSHIFT_DEBUG_ZENO
+      @debug_zeno       ||= $REDSHIFT_DEBUG_ZENO ## why ||= ?
       @zeno_output      ||= $stderr
       super
     end

data/lib/redshift/redshift.rb

@@ -1,22 +1,59 @@
 # Copyright (C) 2001-2010, Joel VanderWerf
 # Distributed under the Ruby license. See www.ruby-lang.org.
 
-# Read all environment variables related to RedShift and store in globals
-## see importenv.rb for a way to keep these in sync
+# RedShift has no command line interface, since it is a library. But it does
+# let you pass in options with any env var named REDSHIFT_*. The variable
+# is accessible as a global $REDSHIFT_*.
+#
+# Some standard env vars recognized by redshift itself:
+#
+# REDSHIFT_BUILD_TIMES  : boolean - show times of each build step
+# REDSHIFT_CGEN_VERBOSE : boolean - passed on to cgen via $CGEN_VERBOSE
+# REDSHIFT_CLIB_NAME    : string  - used as based for dir and .so names
+# REDSHIFT_DEBUG        : int     - debug level (false, 0, or empty to disable)
+# REDSHIFT_DEBUG_ZENO   : boolean - turn on Zeno debugging in zeno-debugger.rb
+# REDSHIFT_MAKE_ARGS    : string  - arguments passed on to make (-j is nice)
+# REDSHIFT_SKIP_BUILD   : boolean - just load .so and run program
+# REDSHIFT_TARGET       : string  - (future) which kind of build
+# REDSHIFT_WORK_DIR     : string  - where to build C lib (default is ./tmp/)
+
+convert_val = proc do |var, val|
+  case var
+  when /\AREDSHIFT_(?:BUILD_TIMES|CGEN_VERBOSE|DEBUG_ZENO|SKIP_BUILD)\z/
+    case val
+    when /\A\s*(false|off|nil|0*)\s*\z/i
+      false
+    else
+      true
+    end
+  when /\AREDSHIFT_DEBUG\z/
+    case val
+    when /\A\s*(false|off|nil|0*)\s*\z/i
+      false
+    when /\A\s*(true|on)\s*\z/i
+      1
+    else
+      val.to_i rescue 1
+    end
+  else
+    val
+  end
+end
+
 ENV.keys.grep(/RedShift/i) do |key|
+  next unless /\A[\w]+\z/ =~ key
   val = ENV[key] # make eval safe
+  val = convert_val[key, val]
   eval "$#{key} = val unless defined? $#{key}"
 end
 
 if $REDSHIFT_DEBUG
-  f = $stderr
-  f.puts "  ----------------------------------------------------------------- "
-  f.puts " |RedShift debugging information enabled by env var REDSHIFT_DEBUG.|"
-  f.puts " |    Please ignore error messages that do not halt the progam.    |"
-  f.puts "  ----------------------------------------------------------------- "
-  f.puts "\n   debug level = #{$REDSHIFT_DEBUG}\n\n" if $REDSHIFT_DEBUG != true
-  
-  $REDSHIFT_DEBUG = ($REDSHIFT_DEBUG.to_i rescue 1)
+  $stderr.puts <<-EOS
+   -----------------------------------------------------------------
+  |RedShift debugging information enabled by env var REDSHIFT_DEBUG.|
+   -----------------------------------------------------------------
+   REDSHIFT_DEBUG = #{$REDSHIFT_DEBUG}
+  EOS
 end
 
 class AssertionFailure < StandardError; end
@@ -33,7 +70,7 @@ end
 module RedShift
   include Math
   
-  VERSION = '1.3.21'
+  VERSION = '1.3.22'
 
   Infinity = Math::Infinity
 

data/lib/redshift/syntax.rb

@@ -402,13 +402,21 @@ module TransitionSyntax
     end
     alias after post
     
-    # +h+ is a hash of :var => proc {value_expr_ruby} or "value_expr_c".
+    # +h+ is a hash of :var => proc {value_expr_ruby} or "value_expr_c" or a literal.
     def reset(h)
       badkeys = h.keys.reject {|k| k.is_a?(Symbol)}
       unless badkeys.empty?
         raise SyntaxError, "Keys #{badkeys.inspect} in reset must be symbols"
       end
       
+      h.keys.each do |k|
+        v = h[k]
+        case v
+        when String
+          h[k] = v.strip
+        end
+      end
+      
       @resets ||= Component::ResetPhase.new
       @resets.value_map ||= {}
       @resets.concat [nil, nil, nil] # continuous, constant, link

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

@@ -57,10 +57,8 @@ module RedShift
         unsigned    ck_strict :  1; // should check strict at end of phase
         unsigned    reset     :  1; // var is being reset
         Flow        flow;           // cached flow function of current state
-        double      value_0;        // value during discrete step
-        double      value_1;        // value at steps of Runge-Kutta
-        double      value_2;
-        double      value_3;
+        double      value[4];       // [0] = value during discrete step
+                                    // [1..3] = value at steps of Runge-Kutta
       } ContVar;
       #ifdef WIN32
       #pragma pack(pop)
@@ -96,52 +94,65 @@ module RedShift
 
       def initialize(*args)
         super
-        # value_0 is the relevant state outside of continuous update
-        @dump = "rb_ary_push(result, rb_float_new(shadow->#{@cvar}.value_0))"
-        @load = "shadow->#{@cvar}.value_0 = NUM2DBL(rb_ary_shift(from_array))"
+        # value[0] is the relevant state outside of continuous update
+        @dump = "rb_ary_push(result, rb_float_new(shadow->#{@cvar}.value[0]))"
+        @load = "shadow->#{@cvar}.value[0] = NUM2DBL(rb_ary_shift(from_array))"
       end
     end
+    
+    def Component.store_wrapper name, wrapper
+      raise unless self == Component
+      @fn_wrapper_by_name ||= {}
+      @fn_wrapper_by_name[name] = wrapper
+    end
 
-    # Useful way to represent an object that has compile time (pre-commit) and
-    # run-time (post-commit) bevahior. The compile time behavior is in the
-    # class, and the run time behavior is in the unique instance.
-    class SingletonShadowClass
-      include Singleton
-      include CShadow; shadow_library Component
-      persistent false
-      def inspect; self.class.inspect_str; end
-      class << self; attr_reader :inspect_str; end
+    def Component.fetch_wrapper name
+      raise unless self == Component
+      @fn_wrapper_by_name && @fn_wrapper_by_name[name]
     end
 
     # FunctionWrappers wrap function pointers for access from ruby.
-    class FunctionWrapper < SingletonShadowClass
-      def initialize
-        calc_function_pointer
-      end
+    class FunctionWrapper
+      include CShadow; shadow_library Component
+      persistent false
       
-      class << self
-        attr_accessor :constructor
+      class RedShift::Flow ### move this
+        # Function name and file name
+        attr_reader :fname
         
-        def construct
-          class_eval &constructor
+        attr_reader :inspect_str
+
+        # proc to build the function in the file
+        attr_reader :generator
+        
+        def generate
+          ## create the file?
+          generator.call unless @generated
+          @generated = true
         rescue => ex
-          ex.message << " While defining #{inspect_str}."
+          ex.message << " While defining #{inspect}."
           raise
         end
         
-        def make_subclass(file_name, &bl)
-          cl = Class.new(self)
-          cl.constructor = bl
-          cl.shadow_library_file file_name
-          clname = file_name.sub /^#{@tag}/i, @tag
-          Object.const_set clname, cl ## maybe put in other namespace?
-          before_commit {cl.construct}
-            # this is deferred to commit time to resolve forward refs
-            ## this would be more elegant with defer.rb
-            ## maybe precommit should be used for this now?
-          cl
+        # Can be called only after commit.
+        def wrapper
+          raise unless Component.committed?
+          Component.fetch_wrapper(fname)
+        end
+        
+        def inspect; inspect_str; end
+        
+        def become_generatable(*args)
+          make_generator(*args) unless generator
+          self
         end
       end
+      
+      def inspect; @inspect_str; end
+      
+      def initialize inspect_str
+        @inspect_str = inspect_str
+      end
     end
 
     class FlowWrapper < FunctionWrapper
@@ -152,10 +163,8 @@ module RedShift
 
     class GuardWrapper < FunctionWrapper
       shadow_attr :guard => "Guard guard"
+      shadow_attr_reader :strict => "boolean strict"
       @tag = "Guard"
-
-      def self.strict; @strict; end
-      def strict; @strict ||= self.class.strict; end
     end
     
     class ExprWrapper < FunctionWrapper
@@ -327,7 +336,7 @@ module RedShift
       unsigned    unused    : 11;
       union {
         struct {
-          unsigned idx      : 16; //# index of next transition after sync failure
+          unsigned idx      : 16; //# index of next trans after sync failure
         } trans;
       } tmp;
     }
@@ -342,10 +351,6 @@ module RedShift
         @flow_hash ||= {}
       end
 
-      def add_flow h      # [state, var] => flow_wrapper_subclass, ...
-        flow_hash.update h
-      end
-
       def flow_table
         unless @flow_table
           assert committed?
@@ -355,8 +360,8 @@ module RedShift
               ft[k] = v.dup
             end
           end
-          for (state, var), flow_class in flow_hash
-            (ft[state] ||= [])[var.index] = flow_class.instance
+          for (state, var), flow in flow_hash
+            (ft[state] ||= [])[var.index] = flow.wrapper
           end
           @flow_table = ft
         end
@@ -386,7 +391,7 @@ module RedShift
           var_name = var_name.intern if var_name.is_a? String
           
           cont_state_class.add_var var_name, kind do
-            ssn = cont_state_class.shadow_struct.name
+            ssn = cont_state_class.shadow_struct_name
             exc = shadow_library.declare_class(AlgebraicAssignmentError)
             msg = "Cannot set #{var_name}; it is defined algebraically."
 
@@ -413,7 +418,7 @@ module RedShift
                 # later, so strictness will get checked at the end of any
                 # transitions (but only if someone has relied on it).
                 
-                returns "rb_float_new(cont_state->#{var_name}.value_0)"
+                returns "rb_float_new(cont_state->#{var_name}.value[0])"
               end
             }
             
@@ -429,7 +434,7 @@ module RedShift
                   declare :cont_state => "#{ssn} *cont_state"
                   body %{
                     cont_state = (#{ssn} *)shadow->cont_state;
-                    cont_state->#{var_name}.value_0 = NUM2DBL(value);
+                    cont_state->#{var_name}.value[0] = NUM2DBL(value);
                     if (shadow->world)
                       shadow->world->d_tick++;
                     if (cont_state->#{var_name}.algebraic)
@@ -448,7 +453,7 @@ module RedShift
                   declare :cont_state => "#{ssn} *cont_state"
                   body %{
                     cont_state = (#{ssn} *)shadow->cont_state;
-                    cont_state->#{var_name}.value_0 = NUM2DBL(value);
+                    cont_state->#{var_name}.value[0] = NUM2DBL(value);
                     if (shadow->world) 
                       shadow->world->d_tick++;
                     if (cont_state->#{var_name}.algebraic)
@@ -549,6 +554,15 @@ module RedShift
 
         check_variables
       end
+      
+      def generate_wrappers
+        hs = [flow_hash, @guard_hash, @expr_hash]
+        hs.compact.each do |h|
+          h.values.sort_by{|f| f.fname}.each do |flow|
+            flow.generate ### should rename Flow class to Function or such
+          end
+        end
+      end
     
       def define_events
         exported_events.own.each do |event, index|
@@ -593,7 +607,7 @@ module RedShift
       end
       
       def add_var_to_offset_table var_name
-        ssn = shadow_struct.name
+        ssn = shadow_struct_name
         lit = shadow_library.literal_symbol(var_name,
           shadow_library_source_file)
         offset_table_method.body %{\
@@ -603,7 +617,7 @@ module RedShift
       end
 
       def define_links
-        ssn = shadow_struct.name
+        ssn = shadow_struct_name
         
         link_variables.own.keys.sort_by{|k|k.to_s}.each do |var_name|
           var_type, strictness = link_variables[var_name]
@@ -673,16 +687,18 @@ module RedShift
       def define_flows(state)
         own_flows = flows(state).own
         own_flows.keys.sort_by{|sym|sym.to_s}.each do |var|
-          flow = own_flows[var]
+          define_flow own_flows[var], state, var
+        end
+      end
 
-          cont_var = cont_state_class.vars[var]
-          unless cont_var
-            attach_continuous_variables(:permissive, [var])
-            cont_var = define_continuous(:permissive, [var])[0]
-          end
-          
-          add_flow([state, cont_var] => flow_wrapper(flow, state))
+      def define_flow flow, state, var
+        cont_var = cont_state_class.vars[var]
+        unless cont_var
+          attach_continuous_variables(:permissive, [var])
+          cont_var = define_continuous(:permissive, [var])[0]
+        end
 
+        flow_hash[ [state, cont_var] ] ||= begin
           after_commit do
             ## a pity to use after_commit, when "just_before_commit" would be ok
             ## use the defer mechanism from teja2hsif
@@ -692,19 +708,17 @@ module RedShift
                 "redefined with non-strict flow.", []
             end
           end
+
+          @flow_wrapper_hash ||= {}
+          @flow_wrapper_hash[ [flow.var, flow.formula] ] ||=
+            flow.become_generatable(self, state)
         end
       end
-      
-      def flow_wrapper flow, state
-        @flow_wrapper_hash ||= {}
-        @flow_wrapper_hash[ [flow.var, flow.formula] ] ||=
-          flow.flow_wrapper(self, state)
-      end
 
       def define_guard(expr)
-        @guard_wrapper_hash ||= {} ## could be a superhash?
-        @guard_wrapper_hash[expr] ||=
-          CexprGuard.new(expr).guard_wrapper(self)
+        @guard_hash ||= {} ## could be a superhash?
+        @guard_hash[expr] ||=
+          CexprGuard.new(expr).become_generatable(self)
       end
 
       def make_guard_method_name
@@ -736,18 +750,25 @@ module RedShift
               g # a proc is slower than a method when called from step_discrete
             end
           
-          when Class
-            if g < GuardWrapper
-              g
-            else
-              raise "What is #{g.inspect}?"
-            end
-
           when String
             define_guard(g)
           
+          when CexprGuard
+            # already defined (shared guards)
+            g
+
           else
-            raise "What is #{g.inspect}?"
+            raise "Can't define guard for #{g.class} : #{g.inspect}"
+          end
+        end
+        after_commit do
+          guards.map! do |g|
+            case g
+            when CexprGuard
+              g.wrapper
+            else
+              g
+            end
           end
         end
       end
@@ -755,7 +776,8 @@ module RedShift
       def define_syncs syncs
         after_commit do
           syncs.each do |sync_phase_item|
-            sync_phase_item.link_offset = offset_of_var(sync_phase_item.link_name)
+            sync_phase_item.link_offset =
+              offset_of_var(sync_phase_item.link_name)
           end
         end
       end
@@ -776,9 +798,9 @@ module RedShift
       end
       
       def define_reset(expr, type = "double")
-        @expr_wrapper_hash ||= {} ## could be a superhash?
-        @expr_wrapper_hash[expr] ||=
-          ResetExpr.new(expr, type).wrapper(self)
+        @expr_hash ||= {} ## could be a superhash?
+        @expr_hash[expr] ||=
+          ResetExpr.new(expr, type).become_generatable(self)
       end
       
       def define_resets(phase)
@@ -811,7 +833,7 @@ module RedShift
           reset = define_reset(expr)
 
           after_commit do
-            phase[cont_var.index] = reset.instance
+            phase[cont_var.index] = reset.wrapper
           end
         
         when Numeric
@@ -837,7 +859,7 @@ module RedShift
           reset = define_reset(expr)
 
           after_commit do
-            phase << [offset_of_var(var), reset.instance, var]
+            phase << [offset_of_var(var), reset.wrapper, var]
           end
 
         when Numeric
@@ -864,7 +886,7 @@ module RedShift
           reset = define_reset(expr, "ComponentShadow *")
 
           after_commit do
-            phase << [offset_of_var(var), reset.instance, var, type]
+            phase << [offset_of_var(var), reset.wrapper, var, type]
           end
 
         when Proc, NilClass
@@ -878,9 +900,9 @@ module RedShift
         phase.each do |item|
           case item.value
           when ExprEventValue
-            wrapper_mod = define_reset(item.value)
+            reset = define_reset(item.value)
             after_commit do
-              item.value = wrapper_mod.instance
+              item.value = reset.wrapper
             end
           end
         end
@@ -1054,6 +1076,78 @@ module RedShift
     end
     ## end # if need connect
 
+    library.source_file.declare :INIT_WRAPPER_DEFS => %{
+      #define ALGEBRAIC 1
+      #define NONALGEBRAIC 0
+      #define STRICT 1
+      #define NONSTRICT 0
+    }
+
+    library.define(:s_init_flow).instance_eval do
+      arguments "void (*fn)()", "char *fname", "char *inspect_str", "int alg"
+
+      fw_ssn = Component::FlowWrapper.shadow_struct_name
+      fw_cname = library.declare_class Component::FlowWrapper
+      comp_cname = library.declare_class Component
+      id_new = library.declare_symbol :new
+      id_store_wrapper = library.declare_symbol :store_wrapper
+
+      body %{\
+        #{fw_ssn} *fw_shadow;
+        VALUE fw;
+
+        fw = rb_funcall(#{fw_cname}, #{id_new}, 1, rb_str_new2(inspect_str));
+        Data_Get_Struct(fw, #{fw_ssn}, fw_shadow);
+        fw_shadow->flow = fn;
+        fw_shadow->algebraic = alg;
+        rb_funcall(#{comp_cname}, #{id_store_wrapper}, 2,
+          rb_str_new2(fname), fw);
+      }.rstrip
+    end
+
+    library.define(:s_init_guard).instance_eval do
+      arguments "void (*fn)()", "char *fname", "char *inspect_str", "int strict"
+
+      gw_ssn = Component::GuardWrapper.shadow_struct_name
+      gw_cname = library.declare_class Component::GuardWrapper
+      comp_cname = library.declare_class Component
+      id_new = library.declare_symbol :new
+      id_store_wrapper = library.declare_symbol :store_wrapper
+
+      body %{\
+        #{gw_ssn} *gw_shadow;
+        VALUE gw;
+
+        gw = rb_funcall(#{gw_cname}, #{id_new}, 1, rb_str_new2(inspect_str));
+        Data_Get_Struct(gw, #{gw_ssn}, gw_shadow);
+        gw_shadow->guard = fn;
+        gw_shadow->strict = strict;
+        rb_funcall(#{comp_cname}, #{id_store_wrapper}, 2,
+          rb_str_new2(fname), gw);
+      }.rstrip
+    end
+
+    library.define(:s_init_expr).instance_eval do
+      arguments "void (*fn)()", "char *fname", "char *inspect_str"
+
+      ew_ssn = Component::ExprWrapper.shadow_struct_name
+      ew_cname = library.declare_class Component::ExprWrapper
+      comp_cname = library.declare_class Component
+      id_new = library.declare_symbol :new
+      id_store_wrapper = library.declare_symbol :store_wrapper
+
+      body %{\
+        #{ew_ssn} *ew_shadow;
+        VALUE ew;
+
+        ew = rb_funcall(#{ew_cname}, #{id_new}, 1, rb_str_new2(inspect_str));
+        Data_Get_Struct(ew, #{ew_ssn}, ew_shadow);
+        ew_shadow->expr = fn;
+        rb_funcall(#{comp_cname}, #{id_store_wrapper}, 2,
+          rb_str_new2(fname), ew);
+      }.rstrip
+    end
+
     define_c_method :clear_ck_strict do
       declare :locals => %{
         ContVar    *vars;
@@ -1100,9 +1194,9 @@ module RedShift
 
     ## can this go in shadow_library_source_file instead of library?
     library.define(:rs_update_cache).instance_eval do
-      flow_wrapper_type = Component::FlowWrapper.shadow_struct.name
+      flow_wrapper_type = Component::FlowWrapper.shadow_struct_name
       scope :extern ## might be better to keep static and put in world.c
-      arguments "struct #{Component.shadow_struct.name} *shadow"
+      arguments "struct #{Component.shadow_struct_name} *shadow"
       declare :locals => %{
         #{flow_wrapper_type} *flow_wrapper;
 
@@ -1160,7 +1254,7 @@ module RedShift
                 has_diff = 1;
               if (var->flow && var->algebraic && var->strict &&
                   var->d_tick > 0) { //# did anyone rely on the strictness?
-                var->value_1    = var->value_0;
+                var->value[1]    = var->value[0];
                 var->ck_strict  = 1;
               }
               else {
@@ -1282,7 +1376,7 @@ module RedShift
                 var->d_tick = sh->world->d_tick;
             }
 
-            result = (&var->value_0)[sh->world->rk_level];
+            result = var->value[sh->world->rk_level];
             break;
           }
 
@@ -1292,7 +1386,7 @@ module RedShift
 
           case INPUT_INP_VAR:
             tgt = (struct target *)(tgt->psh + tgt->offset);
-            if (depth++ > 100) {
+            if (depth++ > sh->world->input_depth_limit) {
               size_t offset = psrc_comp - (char *)shadow;
               VALUE str = rb_funcall(shadow->self,
                 #{declare_symbol :get_varname_by_offset}, 1, INT2FIX(offset));