Changeset 57:0ad68c5ba3f5 in finroc_core


Ignore:
Timestamp:
10.12.2010 15:54:24 (9 years ago)
Author:
Max Reichardt <reichardt@…>
Branch:
default
Phase:
public
Convert:
svn:b083a55c-8fa7-4c4f-93b4-8bdc53b56238/trunk@58
Message:

Cleaned up project:
Removed tons of ancient code that was commented out some time ago

Files:
59 edited

Legend:

Unmodified
Added
Removed
  • buffers/tCoreInput.h

    r27 r57  
    9191  } 
    9292 
    93   //  /** 
    94   //   * Deserialize object from stream with fixed type 
    95   //   * 
    96   //   * \param to Object to read 
    97   //   */ 
    98   //  public void readObject(TypedObject to) { 
    99   //      readSkipOffset(); 
    100   //      if (to == null) { 
    101   //          throw new RuntimeException("Provided object is null"); 
    102   //      } else { 
    103   //          to.deserialize(this); 
    104   //      } 
    105   //  } 
    106  
    10793  /*! 
    10894   * Deserialize object with variable type from stream 
  • datatype/tCoreNumber.h

    r35 r57  
    7272  /*! Register Data type */ 
    7373  static tDataType* const cTYPE; 
    74  
    75   /*@Override 
    76   public short getUid() { 
    77       return 8; //(short)serialVersionUID; 
    78   //}*/ 
    7974 
    8075  // number serialization: 
  • datatype/tFrameworkElementInfo.h

    r29 r57  
    128128  tFrameworkElementInfo(); 
    129129 
    130   //  /** 
    131   //   * Serialize data type update information 
    132   //   * 
    133   //   * \param dt Data type 
    134   //   * \param tp Packet to serialize to 
    135   //   */ 
    136   //  public static void serializeDataType(DataType dt, CoreBuffer tp) { 
    137   //      tp.writeByte(UPDATE_TIME); // write opcode (see base class) 
    138   //      tp.writeInt(-1); 
    139   //      tp.writeShort(dt.getUid()); 
    140   //      tp.writeInt(0); 
    141   //      tp.writeInt(1); 
    142   //      tp.writeByte((byte)0); 
    143   //  } 
    144  
    145130  /*! 
    146131   * \param is Input Stream to deserialize from 
     
    182167  } 
    183168 
    184   //  @Override 
    185   //  public Integer getKey() { 
    186   //      return handle; 
    187   //  } 
    188  
    189   //  @Override 
    190   //  public void handleChange(CoreByteBuffer buffer) { 
    191   //      // actually not used... but never mind 
    192   //      buffer.reset(); 
    193   //      byte command = buffer.readByte(); 
    194   //      int value = buffer.readInt(); 
    195   //      if (command == UPDATE_TIME) { 
    196   //          minUpdateInterval = (short)value; 
    197   //      } else if (command == flags) { 
    198   //          flags = value; 
    199   //      } 
    200   //  } 
    201  
    202169  /*! 
    203170   * \return the index 
     
    217184  } 
    218185 
    219   // 
    220   //  /** 
    221   //   * \return List with links for this port 
    222   //   */ 
    223   //  @ConstMethod public @Const @Ref SimpleList<String> getLinks() { 
    224   //      return links; 
    225   //  } 
    226  
    227   //  /** 
    228   //   * \return List with links for this port 
    229   //   */ 
    230   //  @ConstMethod public @Const @Ref SimpleList<Integer> getParents() { 
    231   //      return parents; 
    232   //  } 
    233  
    234186  /*! 
    235187   * number of parents/links 
     
    239191    return link_count; 
    240192  } 
    241  
    242   //  /** 
    243   //   * \param index Index of parent 
    244   //   * \return Handle of parent 
    245   //   */ 
    246   //  @ConstMethod public int getParentHandle(int index) { 
    247   //      return (int)(parents.get(index) >> 8); 
    248   //  } 
    249   // 
    250   //  /** 
    251   //   * \param index Index of parent 
    252   //   * \return Handle of parent 
    253   //   */ 
    254   //  @ConstMethod public int getParentFlags(int index) { 
    255   //      return links 
    256   //  } 
    257193 
    258194  /*! 
  • datatype/tPortCreationList.h

    r27 r57  
    149149public: 
    150150 
    151   /*! Further io vectors that list might be wrapping */ 
    152151  tPortCreationList(); 
    153  
    154   //    /** 
    155   //     * Add another IO vector that will be managed by this list 
    156   //     * (if its already in list, flags will be adjusted) 
    157   //     * 
    158   //     * \param ioVector IO vector to manage 
    159   //     * \param flags Flags to use 
    160   //     */ 
    161   //    public void addManaged(FrameworkElement ioVector, int flags) { 
    162   //        synchronized(managed.ioVector) { 
    163   //            for (int i = 0; i < moreIoVectors.size(); i++) { 
    164   //                if (moreIoVectors.get(i).ioVector == ioVector) { 
    165   //                    moreIoVectors.get(i).flags = flags; 
    166   //                    applyChanges(moreIoVectors.get(i)); 
    167   //                    return; 
    168   //                } 
    169   //            } 
    170   //            moreIoVectors.add(new ManagedIOVector(ioVector, flags)); 
    171   //            applyChanges(moreIoVectors.get(moreIoVectors.size() - 1)); 
    172   //        } 
    173   //    } 
    174   // 
    175   //    /** 
    176   //     * Remove framework element from list of managed IO vectors 
    177   //     * 
    178   //     * \param ioVector IO vector to remove 
    179   //     */ 
    180   //    public void removeManaged(FrameworkElement ioVector) { 
    181   //        synchronized(managed.ioVector) { 
    182   //            for (int i = 0; i < moreIoVectors.size(); i++) { 
    183   //                if (moreIoVectors.get(i).ioVector == ioVector) { 
    184   //                    moreIoVectors.remove(i); 
    185   //                } 
    186   //            } 
    187   //        } 
    188   //    } 
    189152 
    190153  /*! 
  • parameter/tBoolStructureParameter.h

    r31 r57  
    8383  } 
    8484 
    85   /*! 
    86    * Interprets/returns value in other (cloned) list 
    87    * 
    88    * \param list other list 
    89    * \return Value in other list 
    90    */ 
    91   /*public boolean interpretSpec(StructureParameterList list) { 
    92       BoolStructureParameter param = (BoolStructureParameter)list.get(listIndex); 
    93       assert(param.getType() == getType()); 
    94       return param.get(); 
    95   }*/ 
    96  
    9785}; 
    9886 
  • parameter/tEnumStructureParameter.h

    r42 r57  
    9595  void Set(E default_value); 
    9696 
    97   /*! 
    98    * Interprets/returns value in other (cloned) list 
    99    * 
    100    * \param list other list 
    101    * \return Value in other list 
    102    */ 
    103   /*@SuppressWarnings("unchecked") 
    104   public E interpretSpec(StructureParameterList list) { 
    105       EnumStructureParameter<E> param = (EnumStructureParameter<E>)list.get(listIndex); 
    106       assert(param.getType() == getType()); 
    107       return param.get(); 
    108   }*/ 
    109  
    11097}; 
    11198 
  • parameter/tNumericStructureParameter.h

    r31 r57  
    114114  } 
    115115 
    116   /*! 
    117    * Interprets/returns value in other (cloned) list 
    118    * 
    119    * \param list other list 
    120    * \return Value in other list 
    121    */ 
    122   /*@SuppressWarnings("unchecked") 
    123   public T interpretSpec(StructureParameterList list) { 
    124       NumericStructureParameter<T> param = (NumericStructureParameter<T>)list.get(listIndex); 
    125       assert(param.getType() == getType()); 
    126       return param.get(); 
    127   }*/ 
    128  
    129116}; 
    130117 
  • parameter/tStringStructureParameter.h

    r42 r57  
    8282  } 
    8383 
    84   /*! 
    85    * Interprets/returns value in other (cloned) list 
    86    * 
    87    * \param list other list 
    88    * \return Value in other list 
    89    */ 
    90   /*public String interpretSpec(StructureParameterList list) { 
    91       StringStructureParameter param = (StringStructureParameter)list.get(listIndex); 
    92       assert(param.getType() == getType()); 
    93       return param.get(); 
    94   }*/ 
    95  
    9684}; 
    9785 
  • parameter/tStructureParameter.h

    r31 r57  
    122122  } 
    123123 
    124   /*! 
    125    * Interprets/returns value in other (cloned) list 
    126    * 
    127    * \param list other list 
    128    * \return Value in other list 
    129    */ 
    130   /*@SuppressWarnings("unchecked") 
    131   public T interpret(StructureParameterList list) { 
    132       StructureParameter<T> param = (StructureParameter<T>)list.get(listIndex); 
    133       assert(param.getType() == getType()); 
    134       return param.getValue(); 
    135   }*/ 
    136  
    137124}; 
    138125 
  • plugin/tCreateExternalConnectionAction.h

    r27 r57  
    5555  virtual int GetFlags() const = 0; 
    5656 
    57 //  /** Constructor to invoke */ 
    58 //  private Class<? extends ExternalConnection> c; 
    59 // 
    60 //  /** Default object when returning empty parameter list */ 
    61 //  private static final Class<?>[] params = new Class<?>[]{String.class}; 
    62 // 
    63 //  /** 
    64 //   * \param m wrapped method 
    65 //   * \param group method's group 
    66 //   */ 
    67 //  public CreateExternalConnectionAction(Class<? extends ExternalConnection> c) { 
    68 //      this.c = c; 
    69 //  } 
    70 // 
    71 //  @Override 
    72 //  public ExternalConnection createModule(Object... params) throws Exception { 
    73 //      return createModule(params[0].toString()); 
    74 //  } 
    75 // 
    76 //  public ExternalConnection createModule(String address) throws Exception { 
    77 //      ExternalConnection m = (ExternalConnection)c.newInstance(); 
    78 //      m.connect(address); 
    79 //      return m; 
    80 //  } 
    81 // 
    82 //  /** 
    83 //   * Create Connection Module. Window will pop up and ask for address. 
    84 //   * 
    85 //   * \return Created Connection Module 
    86 //   */ 
    87 //  public ExternalConnection createModule() throws Exception { 
    88 //      ExternalConnection m = (ExternalConnection)c.newInstance(); 
    89 //      m.connect(null); 
    90 //      return m; 
    91 //  } 
    92 // 
    93 //  @Override 
    94 //  public Class<?>[] getParameterTypes() { 
    95 //      return params; 
    96 //  } 
    97 // 
    98 //  @Override 
    99 //  public String toString() { 
    100 //      return c.getSimpleName(); 
    101 //  } 
    102 // 
    103 //  @Override 
    104 //  public String getModuleGroup() { 
    105 //      return ExternalConnection.GROUP_NAME; 
    106 //  } 
    107  
    10857}; 
    10958 
  • plugin/tExternalConnection.h

    r27 r57  
    191191  } 
    192192 
    193 //  protected class ConnectionListenerManager extends WeakRefListenerManager<ConnectionListener> { 
    194 // 
    195 //      @Override 
    196 //      protected void notifyObserver(ConnectionListener observer, Object... param) { 
    197 //          observer.connectionEvent(ExternalConnection.this, (Event)param[0]); 
    198 //      } 
    199 //  } 
    200  
    201193}; 
    202194 
  • plugin/tPlugins.h

    r50 r57  
    161161  tCreateExternalConnectionAction* RegisterExternalConnection(tCreateExternalConnectionAction* action); 
    162162 
    163   // 
    164   //  /** PluginsListener */ 
    165   //  private final List<PluginsListener> pluginsListener = new ArrayList<PluginsListener>(); 
    166   // 
    167   //  /** 
    168   //   * Flag for indicating whether listeners should be notified after add operation 
    169   //   * (good idea to deactivate and afterwards reactivate when adding a bunch of plugins) 
    170   //   */ 
    171   //  private boolean notify = true; 
    172   // 
    173   //  /** List with a set of actions that can be used to create Modules/Groups that are contained in all loaded Plugins. */ 
    174   //  private final List<CreateModuleAction> pluginModules = new ArrayList<CreateModuleAction>(); 
    175   //  private final List<CreateModuleAction> pluginModulesU = Collections.unmodifiableList(pluginModules); 
    176   // 
    177   //  /** List with a set of actions that can be used to create Connection modules that are contained in all loaded Plugins. */ 
    178   //  private final List<CreateExternalConnectionAction> connectionModules = new ArrayList<CreateExternalConnectionAction>(); 
    179   //  private final List<CreateExternalConnectionAction> connectionModulesU = Collections.unmodifiableList(connectionModules); 
    180   // 
    181   //  /** Class loader for plugins */ 
    182   //  private PluginClassLoader classLoader; 
    183   // 
    184   //  /** List with Widget classes */ 
    185   //  private final List<Class<? extends Widget>> widgetClasses = new ArrayList<Class<? extends Widget>>(); 
    186   //  private final List<Class<? extends Widget>> widgetClassesU = Collections.unmodifiableList(widgetClasses); 
    187   // 
    188   //  /** GUI file codecs list */ 
    189   //  private final List<GUICodec> guiCodecs = new ArrayList<GUICodec>(); 
    190   //  private final List<GUICodec> guiCodecsU = Collections.unmodifiableList(guiCodecs); 
    191   // 
    192   // 
    193   //  @SuppressWarnings("unchecked") 
    194   //  private Plugins() { 
    195   // 
    196   //      // add widgets from widget package 
    197   //      try { 
    198   //          for (Class<?> c : Files.getPackageClasses(GUI_ROOT_CLASS, WIDGETPACKAGENAME)) { 
    199   //              if (Widget.class.isAssignableFrom(c)) { 
    200   //                  widgetClasses.add((Class<? extends Widget>)c); 
    201   //                  JmcaguiXmlSerializer.getInstance().alias(c.getSimpleName(), c); 
    202   //              } 
    203   //          } 
    204   //      } catch (Exception e) { 
    205   //          e.printStackTrace(); 
    206   //      } 
    207   // 
    208   //      guiCodecs.add(new JGUI1Importer()); 
    209   //  } 
    210   // 
    211  
    212163  /*! 
    213164   * Loads plugins 
     
    219170  } 
    220171 
    221 // 
    222 //  /** 
    223 //   * Add Plugin to set of Plugins 
    224 //   * 
    225 //   * \param pluginClass Fully qualified Plugin class the implements Plugin interface 
    226 //   * \param jar Jar File that contains ALL files that are necessary for the plugin (including libraries) 
    227 //   */ 
    228 //  @SuppressWarnings("unchecked") 
    229 //  public synchronized void loadPlugin(Manifest mf) throws Exception { 
    230 //      String className = mf.getMainAttributes().getValue("Plugin-Class"); 
    231 //      String dependenciesS = mf.getMainAttributes().getValue("Dependencies"); 
    232 //      List<String> dependencies = new ArrayList<String>(); 
    233 //      if (dependenciesS != null) { 
    234 //          dependencies.addAll(Arrays.asList(dependenciesS.split(","))); 
    235 //      } 
    236 //      Class<? extends Plugin> c; 
    237 // 
    238 //      if (!(RuntimeSettings.isDebugging() || RuntimeSettings.isRunningInApplet() > 0)) { 
    239 // 
    240 //          // Are dependencies met? 
    241 //          for (String dependency : dependencies) { 
    242 //              classLoader.loadClass(dependency); 
    243 //          } 
    244 // 
    245 //          // Classloader needed for plugins in separate .jars 
    246 //          c = (Class<? extends Plugin>)classLoader.loadClass(className); 
    247 //      } else { 
    248 // 
    249 //          // Are dependencies met? 
    250 //          for (String dependency : dependencies) { 
    251 //              Class.forName(dependency); 
    252 //          } 
    253 // 
    254 //          c = (Class<? extends Plugin>)Class.forName(className); 
    255 //      } 
    256 // 
    257 //      // Is Plugin? 
    258 //      if (!Plugin.class.isAssignableFrom(c)) { 
    259 //          throw new Exception(className + " is not a plugin class."); 
    260 //      } 
    261 //      System.out.println("Found plugin: " + className); 
    262 // 
    263 //      // ensure that plugin is loaded only once 
    264 //      for (int i = 0; i < plugins.size(); i++) { 
    265 //          if (plugins.get(i).getClass().getName().equals(c.getName())) { 
    266 //              plugins.remove(i); 
    267 //              break; 
    268 //          } 
    269 //      } 
    270 // 
    271 //      // add and initialize plugin 
    272 //      Plugin plugin = c.newInstance(); 
    273 //      plugins.add(plugin); 
    274 // 
    275 //      // add modules 
    276 //      CreateModuleAction[] cmas = plugin.getPluginModules(); 
    277 //      if (cmas != null) { 
    278 //          pluginModules.addAll(Arrays.asList(cmas)); 
    279 //          for (CreateModuleAction cma : cmas) { 
    280 //              if (cma instanceof CreateExternalConnectionAction) { 
    281 //                  connectionModules.add((CreateExternalConnectionAction)cma); 
    282 //              } 
    283 //          } 
    284 //      } 
    285 // 
    286 //      // add data types 
    287 //      Class<PortData>[] dataTypes = plugin.getDataTypes(); 
    288 //      if (dataTypes != null) { 
    289 //          DataTypeRegister.getInstance().add(dataTypes); 
    290 //      } 
    291 // 
    292 //      if (plugin instanceof GUIPlugin) { 
    293 // 
    294 //          // add widgets 
    295 //          Class<? extends Widget>[] w = ((GUIPlugin)plugin).getWidgets(); 
    296 //          if (w != null) { 
    297 //              for (Class<? extends Widget> cl : w) { 
    298 //                  widgetClasses.add(cl); 
    299 //                  JmcaguiXmlSerializer.getInstance().alias(cl.getSimpleName(), cl); 
    300 //              } 
    301 //          } 
    302 // 
    303 //          // add codecs 
    304 //          GUICodec[] codecs = ((GUIPlugin)plugin).getGUICodecs(); 
    305 //          if (c != null) { 
    306 //              guiCodecs.addAll(Arrays.asList(codecs)); 
    307 //          } 
    308 //      } 
    309 // 
    310 //      if (notify) { 
    311 //          notifyPluginsListener(); 
    312 //      } 
    313 //  } 
    314 // 
    315 //  /** 
    316 //   * Add Plugin to set of Plugins 
    317 //   * 
    318 //   * \param pluginClass Fully qualified Plugin class the implements Plugin interface 
    319 //   * \param jar Jar File that contains ALL files that are necessary for the plugin (including libraries) 
    320 //   */ 
    321 //  //@SuppressWarnings("unchecked") 
    322 //  /*public static synchronized void addPlugin(String pluginClass, File jar) throws Exception { 
    323 // 
    324 //      // search for libraries in jar Path 
    325 //      System.out.println("add plugin: " + jar.toString()); 
    326 //      List<URL> urls = new ArrayList<URL>(); 
    327 //      for (File f : jar.getParentFile().listFiles()) { 
    328 //          if (f.getName().endsWith(".jar")) { 
    329 //              urls.add(f.toURI().toURL()); 
    330 //              //System.out.println("add url: " + urls.get(urls.size() - 1).toString()); 
    331 //          } 
    332 //      } 
    333 // 
    334 //      addPlugin(pluginClass, urls.toArray(new URL[0])); 
    335 //  }*/ 
    336 // 
    337 //  /** 
    338 //   * Loads all plugins that are found in the application's root and sub directories. 
    339 //   * More precise: Root directory of the classpath the calling class is in. 
    340 //   * 
    341 //   * The file names need to have the following form: 
    342 //   * 
    343 //   * Jar:  <fully-qualified-classname>.jar 
    344 //   * Conf: <fully-qualified-classname>.conf 
    345 //   */ 
    346 //  public synchronized void addPluginsFromApplicationDir() { 
    347 // 
    348 //      notify = false; 
    349 // 
    350 //      if (!(RuntimeSettings.isDebugging() || RuntimeSettings.isRunningInApplet() > 0)) { 
    351 // 
    352 //          List<URL> allJars = new ArrayList<URL>(); 
    353 //          List<File> pluginMainJars = new ArrayList<File>(); 
    354 // 
    355 //          // collect jars 
    356 //          File rootDir = RuntimeSettings.getRootDir(); 
    357 //          for (File file : rootDir.listFiles()) { 
    358 //              if (file.isDirectory()) { 
    359 //                  // search for jars in dist directory 
    360 //                  String filename = file.getName(); 
    361 //                  File jar = new File(file.getAbsolutePath() + File.separator + filename + ".jar"); 
    362 //                  if (jar.exists()) { 
    363 //                      pluginMainJars.add(jar); 
    364 //                  } 
    365 //                  for (File f : Files.getAllFiles(file, new String[]{"jar"}, false, false)) { 
    366 //                      try { 
    367 //                          allJars.add(f.toURI().toURL()); 
    368 //                      } catch (MalformedURLException e) { 
    369 //                          e.printStackTrace(); 
    370 //                      } 
    371 //                  } 
    372 //              } 
    373 //          } 
    374 // 
    375 //          addToClassLoader(allJars); 
    376 // 
    377 //          // load plugins 
    378 //          for (File pluginJar : pluginMainJars) { 
    379 //              try { 
    380 //                  //String className = new JarFile(pluginJar).getManifest().getMainAttributes().getValue("Plugin-Class"); 
    381 //                  //System.out.println("Found plugin " + filename + "; Plugin class: " + className); 
    382 //                  JarFile jf = new JarFile(pluginJar); 
    383 //                  loadPlugin(jf.getManifest()); 
    384 //                  jf.close(); 
    385 //              } catch (Exception e) { 
    386 //                  System.err.println("Error loading plugin: " + pluginJar.getName()); 
    387 //                  e.printStackTrace(); 
    388 //              } 
    389 //          } 
    390 // 
    391 //      } else { 
    392 // 
    393 //          // search for plugins in subdirectories 
    394 //          for (File folder : Files.getDir(Plugins.class).listFiles()) { 
    395 //              if (folder.isDirectory()) { 
    396 //                  // Plugin (?) 
    397 //                  try { 
    398 //                      for (File mf : folder.listFiles()) { 
    399 //                          if (mf.getName().endsWith(".mf")) { 
    400 //                              //String filename = folder.getName(); 
    401 //                              //String className = new Manifest(new FileInputStream(mf)).getMainAttributes().getValue("Plugin-Class"); 
    402 //                              //System.out.println("Found plugin " + filename + "; Plugin class: " + className); 
    403 //                              InputStream is = new FileInputStream(mf); 
    404 //                              loadPlugin(new Manifest(is)); 
    405 //                              is.close(); 
    406 //                              break; 
    407 //                          } 
    408 //                      } 
    409 //                  } catch (Exception e) { 
    410 //                      System.err.println("Error loading plugin: " + folder.getName()); 
    411 //                      e.printStackTrace(); 
    412 //                  } 
    413 //              } 
    414 //          } 
    415 //      } 
    416 // 
    417 //      notify = true; 
    418 //      notifyPluginsListener(); 
    419 // 
    420 //  } 
    421 // 
    422 //  /** 
    423 //   * Add jar files to class loader. Init class loader if not yet done. 
    424 //   * 
    425 //   * \param jars Jar files to add 
    426 //   */ 
    427 //  private synchronized void addToClassLoader(List<URL> jars) { 
    428 //      if (classLoader == null) { 
    429 //          try { 
    430 //              classLoader = new PluginClassLoader(jars.toArray(new URL[0])); 
    431 //          } catch (Exception e) { 
    432 //              e.printStackTrace(); 
    433 //          } 
    434 //      } else { 
    435 //          for (URL url : jars) { 
    436 //              classLoader.addURL(url); 
    437 //          } 
    438 //      } 
    439 //  } 
    440 // 
    441 // 
    442 //  /** 
    443 //   * Returns all data types that a plugin provides 
    444 //   * 
    445 //   * \return Classes 
    446 //   */ 
    447 //  /*public List<Class<PortData>> getPluginClasses(Class<PortData> t) { 
    448 //      List<Class<PortData>> result = new ArrayList<Class<PortData>>(); 
    449 //      for (Plugin p : plugins) { 
    450 //          Class<PortData>[] pluginResult = p.getDataTypes(); 
    451 //          if (pluginResult != null) { 
    452 //              result.addAll(Arrays.asList(pluginResult)); 
    453 //          } 
    454 //      } 
    455 //      return result; 
    456 //  }*/ 
    457 // 
    458 //  /** 
    459 //   * \return Returns a set of actions that can be used to create Modules/Groups that 
    460 //   * are contained in all loaded Plugins. 
    461 //   */ 
    462 //  public List<CreateModuleAction> getPluginModules() { 
    463 //      return pluginModulesU; 
    464 //  } 
    465 // 
    466 //  /** 
    467 //   * \return Returns a set of actions that can be used to create Modules/Groups that 
    468 //   * are contained in all loaded Plugins. 
    469 //   */ 
    470 //  public List<CreateExternalConnectionAction> getExternalConnections() { 
    471 //      return connectionModulesU; 
    472 //  } 
    473 // 
    474 //  /** 
    475 //   * \return Returns all known widget classes 
    476 //   */ 
    477 //  public List<Class<? extends Widget>> getWidgets() { 
    478 //      return widgetClassesU; 
    479 //  } 
    480 // 
    481 //  /** 
    482 //   * \return Returns all known widget classes 
    483 //   */ 
    484 //  public List<GUICodec> getGUICodecs() { 
    485 //      return guiCodecsU; 
    486 //  } 
    487 // 
    488 // 
    489 //  /** 
    490 //   * Create Module/Group provided by plugin. 
    491 //   * 
    492 //   * \param name Name of CreateModuleAction 
    493 //   * \param addTo Runtime Element to add module/group to 
    494 //   * \param Object Parameters 
    495 //   */ 
    496 //  public FrameworkElement createModule(String name, Group addTo, Object... params) throws Exception { 
    497 //      for (CreateModuleAction cma : pluginModules) { 
    498 //          if (cma.toString().equals(name)) { 
    499 //              FrameworkElement re = cma.createModule(params); 
    500 //              if (addTo == null) { 
    501 //                  addTo = RuntimeEnvironment.getInstance(); 
    502 //              } 
    503 //              if (re instanceof Group) { 
    504 //                  addTo.addGroup((Group)re); 
    505 //              } else if (re instanceof Module) { 
    506 //                  addTo.addModule((Module)re); 
    507 //              } else { 
    508 //                  throw new Exception("Did not create module nor group"); 
    509 //              } 
    510 //              return re; 
    511 //          } 
    512 //      } 
    513 //      throw new RuntimeException("Module " + name + " not found"); 
    514 //  } 
    515 // 
    516 //  /** 
    517 //   * Create External connection provided by plugin. 
    518 //   * 
    519 //   * \param name Name of External Connection class 
    520 //   * \param addTo Runtime Element to add module/group to 
    521 //   * \param address Address to connection 
    522 //   */ 
    523 //  public ExternalConnection createExternalConnection(String name, Group addTo, String address) throws Exception { 
    524 //      for (CreateExternalConnectionAction ceca : connectionModules) { 
    525 //          if (ceca.toString().equalsIgnoreCase(name)) { 
    526 //              ExternalConnection re = ceca.createModule(address); 
    527 //              if (addTo != null) { 
    528 //                  addTo.addModule(re); 
    529 //              } else { 
    530 //                  RuntimeEnvironment.getInstance().addModule(re); 
    531 //              } 
    532 //              return re; 
    533 //          } 
    534 //      } 
    535 //      throw new RuntimeException("Module " + name + " not found"); 
    536 //  } 
    537 // 
    538 //  /** 
    539 //   * Load class that is provided by a plugin. 
    540 //   * This method is only meant for testing 
    541 //   * 
    542 //   * \param class1 Class name 
    543 //   */ 
    544 //  @Deprecated 
    545 //  public Class<?> loadClass(String class1) { 
    546 //      for (Plugin p : plugins) { 
    547 //          try { 
    548 //              return p.getClass().getClassLoader().loadClass(class1); 
    549 //          } catch (ClassNotFoundException e) { 
    550 //              // try next 
    551 //          } 
    552 //      } 
    553 //      return null; 
    554 //  } 
    555 // 
    556 //  /** 
    557 //   * \param pl PluginsListener 
    558 //   */ 
    559 //  public void addPluginsListener(PluginsListener pl) { 
    560 //      if (!pluginsListener.contains(pl)) { 
    561 //          pluginsListener.add(pl); 
    562 //      } 
    563 //  } 
    564 // 
    565 //  /** 
    566 //   * Notifiy PluginsListener of change 
    567 //   */ 
    568 //  public void notifyPluginsListener() { 
    569 //      for (PluginsListener pl : pluginsListener) { 
    570 //          pl.pluginsChanged(); 
    571 //      } 
    572 //  } 
    573 //  /** 
    574 //   * \return Returns HTTP resources provided by all loaded Plugins 
    575 //   */ 
    576 //  public List<HTTPResource> getHTTPResources() { 
    577 //      List<HTTPResource> result = new ArrayList<HTTPResource>(); 
    578 //      for (Plugin p : plugins) { 
    579 //          HTTPResource[] pluginResult = p.getHTTPResources(); 
    580 //          if (pluginResult != null) { 
    581 //              result.addAll(Arrays.asList(pluginResult)); 
    582 //          } 
    583 //      } 
    584 //      return result; 
    585 //  } 
    586 // 
    587 //  @Override 
    588 //  public String getHTTPDirectory() { 
    589 //      return "/Plugins"; 
    590 //  } 
    591 // 
    592 //  @Override 
    593 //  public TreeNode getHTTPDirectoryStructure() { 
    594 //      /*DefaultMutableTreeNode result = new DefaultMutableTreeNode("Plugins"); 
    595 //      for (int i = 0; i < plugins.size(); i++) { 
    596 //          Plugin p = plugins.get(i); 
    597 //          String temp = p.getHTTPResources()[0].getHTTPDirectory(); 
    598 //          result.add(new DefaultMutableTreeNode(temp.substring(9, temp.length() - 1))); 
    599 //      } 
    600 //      return result;*/ 
    601 //      return null; 
    602 //  } 
    603 // 
    604 //  @Override 
    605 //  public HTTPResponse serveHTTP(HttpServletRequest request) { 
    606 //      HTMLResponse response = new HTMLResponse("Plugins"); 
    607 //      HTMLTable table = new HTMLTable("Loaded Plugins", "Name", "Jar"); 
    608 //      for (Plugin p : plugins) { 
    609 //          String jar = ((URLClassLoader)p.getClass().getClassLoader()).getURLs()[0].toString(); 
    610 //          jar = jar.substring(jar.indexOf(File.separator) + 1); 
    611 //          table.addRow(p.getClass().getName(), RuntimeSettings.isDebugging() ? "N/A" : jar); 
    612 //      } 
    613 //      response.getBody().add(table); 
    614 //      return response; 
    615 //  } 
    616  
    617172}; 
    618173 
  • port/cc/tCCInterThreadContainer.h

    r34 r57  
    148148  } 
    149149 
    150   //  /** 
    151   //   * \return Actual data 
    152   //   */ 
    153   //  @OrgWrapper @ConstMethod @Const public CCPortData getDataPtr() { 
    154   //      return (CCPortData)portData.getData(); 
    155   //  } 
    156  
    157150  virtual void Serialize(tCoreOutput& os) const 
    158151  { 
  • port/cc/tCCPortBase.cpp

    r41 r57  
    263263  // return locked data 
    264264  return tc->data; 
    265  
    266   //      ThreadLocalCache tc = ThreadLocalCache.getFast(); 
    267   //      PullCall pc = tc.getUnusedPullCall(); 
    268   //      pc.ccPull = true; 
    269   // 
    270   //      //pullValueRaw(pc); 
    271   //      try { 
    272   //          pc = SynchMethodCallLogic.<PullCall>performSynchCall(pc, this, callIndex, PULL_TIMEOUT); 
    273   //          if (pc.tc != null && pc.tc.threadId != ThreadUtil.getCurrentThreadId()) { // reset thread local cache - if it was set by another thread 
    274   //              pc.tc = null; 
    275   //          } 
    276   //          if (pc.tc == null) { // init new PortDataContainer in thread local cache? 
    277   //              pc.setupThreadLocalCache(); 
    278   //          } 
    279   //          CCPortDataContainer<?> result = pc.tc.data; 
    280   //          result.addLock(); 
    281   //          pc.genericRecycle(); 
    282   //          return result; 
    283   //      } catch (MethodCallException e) { 
    284   //          pc.genericRecycle(); 
    285   //          return getLockedUnsafeInContainer(); 
    286   //      } 
    287265} 
    288266 
  • port/cc/tCCPortBase.h

    r41 r57  
    122122  } 
    123123 
    124   //  protected void receive(@Ptr PortData data, @SizeT int dataRaw, @Ptr CCPortBase origin, @Ptr ThreadLocalCache tli) { 
    125   //      if (standardAssign) { 
    126   //          data.getManager().addReadLock(); 
    127   //          tli.setLastWrittenToPort(handle, data); 
    128   // 
    129   //          // JavaOnlyBlock 
    130   //          value = data; 
    131   // 
    132   //           value = data_raw; 
    133   // 
    134   //          changed = true; 
    135   //          notifyListeners(); 
    136   //      } else { 
    137   //          nonStandardAssign(data, tli); 
    138   //      } 
    139   // 
    140   //      @Ptr ArrayWrapper<CCPortBase> dests = edgesSrc.getIterable(); 
    141   //      for (int i = 0, n = dests.size(); i < n; i++) { 
    142   //          @Ptr CCPortBase pb = dests.get(i); 
    143   //          if (pb != null && (pb.flags | PortFlags.PUSH_STRATEGY) > 0) { 
    144   //              pb.receive(data, dataRaw, this, tli); 
    145   //          } 
    146   //      } 
    147   // 
    148   //      dests = edgesDest.getIterable(); 
    149   //      for (int i = 0, n = dests.size(); i < n; i++) { 
    150   //          @Ptr CCPortBase pb = dests.get(i); 
    151   //          if (pb != null && pb != origin && (pb.flags | PortFlags.PUSH_STRATEGY_REVERSE) > 0) { 
    152   //              pb.receiveReverse(data, dataRaw, tli); 
    153   //          } 
    154   //      } 
    155   //  } 
    156   // 
    157   //  protected void receiveAsOwner(@Ptr PortData data, @SizeT int dataRaw, @Ptr CCPortBase origin, @Ptr ThreadLocalCache tli) { 
    158   //      if (standardAssign) { 
    159   //          data.getManager().addOwnerLock(); 
    160   //          tli.newLastWrittenToPortByOwner(handle, data); 
    161   // 
    162   //          // JavaOnlyBlock 
    163   //          value = data; 
    164   // 
    165   //           value = data_raw; 
    166   // 
    167   //          changed = true; 
    168   //          notifyListeners(); 
    169   //      } else { 
    170   //          nonStandardAssign(data, tli); 
    171   //      } 
    172   // 
    173   //      @Ptr ArrayWrapper<CCPortBase> dests = edgesSrc.getIterable(); 
    174   //      for (int i = 0, n = dests.size(); i < n; i++) { 
    175   //          @Ptr CCPortBase pb = dests.get(i); 
    176   //          if (pb != null && (pb.flags | PortFlags.PUSH_STRATEGY) > 0) { 
    177   //              pb.receiveAsOwner(data, dataRaw, this, tli); 
    178   //          } 
    179   //      } 
    180   // 
    181   //      dests = edgesDest.getIterable(); 
    182   //      for (int i = 0, n = dests.size(); i < n; i++) { 
    183   //          CCPortBase pb = dests.get(i); 
    184   //          if (pb != null && pb != origin && (pb.flags | PortFlags.PUSH_STRATEGY_REVERSE) > 0) { 
    185   //              pb.receiveReverse(data, dataRaw, tli); 
    186   //          } 
    187   //      } 
    188   //  } 
    189   // 
    190   //  private void receiveReverse(@Ptr PortData data, @SizeT int dataRaw, @Ptr ThreadLocalCache tli) { 
    191   //      if (standardAssign) { 
    192   //          data.getManager().addReadLock(); 
    193   //          tli.setLastWrittenToPort(handle, data); 
    194   // 
    195   //          // JavaOnlyBlock 
    196   //          value = data; 
    197   // 
    198   //           value = data_raw; 
    199   // 
    200   //          changed = true; 
    201   //          notifyListeners(); 
    202   //      } else { 
    203   //          nonStandardAssign(data, tli); 
    204   //      } 
    205   //  } 
    206   // 
    207  
    208124  inline void NotifyListeners(tThreadLocalCache* tc) 
    209125  { 
     
    286202    queue->Clear(true); 
    287203  } 
    288  
    289   //  @Override 
    290   //  public TypedObject universalGetAutoLocked() { 
    291   //      CCPortDataRef val = value; 
    292   //      CCPortDataContainer<?> valC = val.getContainer(); 
    293   //      if (valC.getOwnerThread() == ThreadUtil.getCurrentThreadId()) { // if same thread: simply add read lock 
    294   //          valC.addLock(); 
    295   //          return valC; 
    296   //      } 
    297   // 
    298   //      // not the same thread: create auto-locked inter-thread container 
    299   //      ThreadLocalCache tc = ThreadLocalCache.get(); 
    300   //      CCInterThreadContainer<?> ccitc = tc.getUnusedInterThreadBuffer(getDataType()); 
    301   //      tc.addAutoLock(ccitc); 
    302   //      for(;;) { 
    303   //          ccitc.assign(valC.getDataPtr()); 
    304   //          if (val == value) { // still valid?? 
    305   //              return ccitc; 
    306   //          } 
    307   //          val = value; 
    308   //          valC = val.getContainer(); 
    309   //      } 
    310   //  } 
    311204 
    312205  /*! 
     
    596489  tCCInterThreadContainer<>* GetInInterThreadContainer(); 
    597490 
    598   //  /** 
    599   //   * Pulls port data (regardless of strategy) 
    600   //   * (careful: no auto-release of lock) 
    601   //   * \param intermediateAssign Assign pulled value to ports in between? 
    602   //   * 
    603   //   * \return Pulled locked data 
    604   //   */ 
    605   //  public @Const CCPortDataContainer<?> getPullLockedUnsafeRaw(boolean intermediateAssign) { 
    606   //      return pullValueRaw(intermediateAssign); 
    607   //  } 
    608  
    609491  /*! 
    610492   * Pulls port data (regardless of strategy) and returns it in interhread container 
     
    658540  } 
    659541 
    660   //  @Override 
    661   //  public void invokeCall(PullCall call) { 
    662   //      if (pullValueRaw(call, ThreadLocalCache.get())) { 
    663   //          SynchMethodCallLogic.handleMethodReturn(call); 
    664   //      } 
    665   //  } 
    666   // 
    667   //  /** 
    668   //   * Pull/read current value from source port 
    669   //   * When multiple source ports are available an arbitrary one of them is used. 
    670   //   * (Should only be called by framework-internal classes) 
    671   //   * 
    672   //   * \param pc Various parameters 
    673   //   * \param tc Thread's ThreadLocalCache instance 
    674   //   * \return already returning pulled value (in same thread) 
    675   //   */ 
    676   //  @Virtual public boolean pullValueRaw(PullCall call, ThreadLocalCache tc) { 
    677   //      @Ptr ArrayWrapper<CCPortBase> sources = edgesDest.getIterable(); 
    678   //      if (pullRequestHandler != null) { 
    679   //          call.data = tc.getUnusedInterThreadBuffer(getDataType()); 
    680   //          call.setStatusReturn(); 
    681   //          pullRequestHandler.pullRequest(this, call.data.getDataPtr()); 
    682   //          call.setupThreadLocalCache(); 
    683   //          assign(tc); 
    684   //      } else { 
    685   // 
    686   //          // continue with next-best connected source port 
    687   //          for (@SizeT int i = 0, n = sources.size(); i < n; i++) { 
    688   //              CCPortBase pb = sources.get(i); 
    689   //              if (pb != null) { 
    690   //                  call.pushCaller(this); 
    691   //                  boolean returning = pb.pullValueRaw(call, tc); 
    692   //                  if (returning) { 
    693   //                      @CppUnused 
    694   //                      int x = call.popCaller(); // we're already returning, so we can remove ourselves from caller stack again 
    695   //                      assert(x == getHandle()); 
    696   //                      if (!value.getContainer().contentEquals(call.data.getDataPtr())) { // exploit thread for the calls he made anyway 
    697   //                          call.setupThreadLocalCache(); 
    698   //                          assign(tc); 
    699   //                      } 
    700   //                  } 
    701   //                  if (call.getStatus() != AbstractCall.CONNECTION_EXCEPTION) { 
    702   //                      return returning; 
    703   //                  } 
    704   //              } 
    705   //          } 
    706   // 
    707   //          // no connected source port... pull current value 
    708   //          call.data = getInInterThreadContainer(); 
    709   //          call.setStatusReturn(); 
    710   //      } 
    711   //      return true; 
    712   //  } 
    713   // 
    714   //  @Override 
    715   //  public void handleCallReturn(AbstractCall call) { 
    716   //      assert(call.isReturning(true)); 
    717   // 
    718   //      PullCall pc = (PullCall)call; 
    719   //      if (!value.getContainer().contentEquals(pc.data.getDataPtr())) { 
    720   //          pc.setupThreadLocalCache(); 
    721   //          assign(pc.tc); 
    722   //      } 
    723   // 
    724   //      // continue assignments 
    725   //      if (pc.callerStackSize() > 0) { 
    726   //          pc.returnToCaller(); 
    727   //      } else { 
    728   //          SynchMethodCallLogic.handleMethodReturn(pc); 
    729   //      } 
    730   //  } 
    731  
    732542  /*! 
    733543   * \param pull_request_handler Object that handles pull requests - null if there is none (typical case) 
  • port/cc/tCCPortDataBufferPool.h

    r27 r57  
    137137  } 
    138138 
    139   //  /** 
    140   //   * Reclaim any returned PortDataContainers 
    141   //   */ 
    142   //  private boolean reclaimReturnedBuffers(ThreadLocalCache tc) { 
    143   //      ArrayWrapper<CCPortDataContainer<?>> buffer = tc.reclaimBuffer; 
    144   //      //typically reclaim maximum of 10 buffers to make things more deterministic/predictable 
    145   //      int n = returnedBuffers.dequeue(buffer, buffer.getCapacity()); 
    146   //      for (int i = 0; i < n; i++) { 
    147   //          buffer.get(i).releaseLock(); 
    148   //      } 
    149   //      return n; 
    150   //  } 
    151  
    152   //  @Override @NonVirtual 
    153   //  public void enqueue(@Ptr CCPortDataContainer<? extends CCPortData> pd) { 
    154   //      assert pd.refCounter == 0; 
    155   //      super.enqueue(pd); 
    156   //  } 
    157  
    158139  /*! 
    159140   * Lock release for non-owner threads - appended to returnedBuffers 
  • port/cc/tCCPortQueue.h

    r27 r57  
    7373  } 
    7474 
    75 //  public void enqueue(PortDataReference pdr) { 
    76 //      CCPortQueueElement pqe = getEmptyContainer2(); 
    77 //      assert(pqe.getElement() == null); 
    78 //      assert(!pqe.isDummy()); 
    79 //      pqe.setElement(pdr); 
    80 //      super.enqueueDirect(pqe); 
    81 //  } 
    82  
    83 //  /** 
    84 //   * How many chunks should be allocated in advance? (one is typically far more than enough). 
    85 //   * However, in special cases it might be necessary to preallocate more (if one thread may 
    86 //   * write masses of data to this port in a very short time - this will end in an null pointer exception). 
    87 //   */ 
    88 //  private final int preAllocate; 
    89 // 
    90 //  /** Fragments or chunks that are currently used */ 
    91 //  private final PortQueueFragment[] chunks; 
    92 // 
    93 //  /** Counts number of writes - element is found in chunks[writeIndex & chunkMask]->array[writeIndex & PQF.MASK]*/ 
    94 //  private final AtomicInteger writeIndex = new AtomicInteger(0); 
    95 // 
    96 //  /** Counts number of reads */ 
    97 //  private int readIndex; 
    98 // 
    99 //  /** Mask to and index with to get chunk (see below) */ 
    100 //  private final int chunkMask; 
    101 // 
    102 //  /** above, but unshifted */ 
    103 //  private final int rawChunkMask; 
    104 // 
    105 //  /** 
    106 //   * \param maxElements Maximum number of elements in queue. 
    107 //   * \param preAllocate How many chunks should be allocated in advance? (one is typically far more that enough). 
    108 //   * However, in special cases it might be necessary to preallocate more (if one thread may 
    109 //   * write masses of elements to this port at once - this will end in an null pointer exception). 
    110 //   */ 
    111 //  public PortQueue(int maxElements, int preAllocate) { 
    112 //      int chunkCount = (maxElements - 1 / PortQueueFragment.SIZE) + 1 + 3 + preAllocate; // (3 is for safety/reservation overhead) 
    113 //      int bits = 32 - Integer.numberOfLeadingZeros(chunkCount - 1); 
    114 //      chunkCount = 1 << bits; 
    115 //      chunks = new PortQueueFragment[chunkCount]; 
    116 //      this.preAllocate = Math.min(1, preAllocate); 
    117 // 
    118 //      // calculate mask 
    119 //      rawChunkMask = ((1 << bits) - 1); 
    120 //      chunkMask = rawChunkMask << PortQueueFragment.BITS; 
    121 // 
    122 //      // fill first <preallocate> chunks 
    123 //      for (int i = 0; i < preAllocate; i++) { 
    124 //          chunks[i] = ThreadLocalCache.get().getUnusedPortQueueFragment(); 
    125 //      } 
    126 //  } 
    127 // 
    128 //  /** 
    129 //   * Enqueue element in queue 
    130 //   * (Thread-safe) 
    131 //   * 
    132 //   * \param element Element to add 
    133 //   */ 
    134 //  public void enqueue(PortData element) { 
    135 // 
    136 // 
    137 // 
    138 //      int index = writeIndex.getAndIncrement(); // the only atomic operation necessary 
    139 //      int chunkIdx = index & chunkMask; 
    140 //      int elemIdx = index & PortQueueFragment.MASK; 
    141 //      if (elemIdx == 0) { // time for allocation? 
    142 //          int idx = (chunkIdx + preAllocate) & rawChunkMask; 
    143 //          assert(chunks[idx] == null); 
    144 //          chunks[idx] = ThreadLocalCache.get().getUnusedPortQueueFragment(); 
    145 //      } 
    146 //      assert(chunks[chunkIdx].array[elemIdx] == null); 
    147 //      chunks[chunkIdx].array[elemIdx] = element; 
    148 //  } 
    149 // 
    150 //  /** 
    151 //   * Dequeue element from queue. 
    152 //   * (May only be called by one thread concurrently.) 
    153 //   * 
    154 //   * \return Element returned element 
    155 //   */ 
    156 //  @SuppressWarnings("unchecked") 
    157 //  public T dequeue() { 
    158 //      int index = readIndex; 
    159 //      int chunkIdx = index & chunkMask; 
    160 //      int elemIdx = index & PortQueueFragment.MASK; 
    161 //      T result = (T)chunks[chunkIdx].array[elemIdx]; 
    162 //      if (result != null) { 
    163 //          chunks[chunkIdx].array[elemIdx] = null; 
    164 //          index++; 
    165 //          if (elemIdx == PortQueueFragment.MASK) { // recycle current chunk? 
    166 //              chunks[chunkIdx].recycle(); 
    167 //              chunks[chunkIdx] = null; 
    168 //          } 
    169 //      } 
    170 //      return result; 
    171 //  } 
    172  
    17375}; 
    17476 
  • port/cc/tCCPortQueueElement.h

    r27 r57  
    5252  tCCPortQueueElement() {} 
    5353 
    54   //PortDataReference ref; 
    55  
    56   //  /** Number of bits for fragment index/size - currently 128 elements */ 
    57   //  public static final @SizeT int BITS = 7; 
    58   // 
    59   //  /** Size of one backend chunk - must be 2^n */ 
    60   //  public static final @SizeT int SIZE = 1 << BITS; 
    61   // 
    62   //  /** Mask to add absolute index with */ 
    63   //  public static final @SizeT int MASK = SIZE - 1; 
    64   // 
    65   //  /** Array backend for chunk */ 
    66   //  @InCpp("void* array[SIZE];") 
    67   //  Object[] array = new Object[SIZE]; 
    68   // 
    69   //  public PortQueueFragment() { 
    70   // 
    71   //      // initialize array 
    72   //      for (size_t i = 0; i < CHUNK_SIZE; i++) { 
    73   //          array[i] = NULL; 
    74   //      } 
    75   // 
    76   //  } 
    77   // 
    78   /*  @Override 
    79       public void recycle() { 
    80           super.recycle(); 
    81       }*/ 
    82  
    8354  inline void Recycle(bool recycle_content) 
    8455  { 
  • port/net/tNetPort.h

    r28 r57  
    193193  } 
    194194 
    195   //  /** 
    196   //   * Process incoming pull call from the network 
    197   //   * 
    198   //   * \param mc PullCall 
    199   //   * \return Did call immediately return with valid result? - Should often be the case 
    200   //   */ 
    201   //  public boolean handlePullFromNet(PullCall mc) { 
    202   //      AbstractPort ap = getPort(); 
    203   //      if (ap instanceof StdNetPort) { 
    204   //          return ((StdNetPort)ap).handlePullFromNet(mc); 
    205   //      } else if (ap instanceof CCNetPort) { 
    206   //          return ((CCNetPort)ap).handlePullFromNet(mc); 
    207   //      } else { 
    208   //          throw new RuntimeException("Port can't handle call from net"); 
    209   //      } 
    210   //  } 
    211   // 
    212   //  /** 
    213   //   * Process incoming (pull) returning call from the network 
    214   //   * 
    215   //   * \param mc Call 
    216   //   */ 
    217   //  public void handleCallReturnFromNet(AbstractCall mc) { 
    218   //      SynchMethodCallLogic.handleMethodReturn(mc); 
    219   //      AbstractPort ap = getPort(); 
    220   //      if (ap instanceof StdNetPort) { 
    221   //          ((StdNetPort)ap).handleCallReturnFromNet(mc); 
    222   //      } else if (ap instanceof CCNetPort) { 
    223   //          ((CCNetPort)ap).handleCallReturnFromNet(mc); 
    224   //      } else if (ap instanceof InterfaceNetPortImpl) { 
    225   //          ((InterfaceNetPortImpl)ap).handleCallReturnFromNet(mc); 
    226   //      } else { 
    227   //          throw new RuntimeException("Port can't handle call return from net"); 
    228   //      } 
    229   //  } 
    230  
    231195  /*! 
    232196   * Process incoming (pull) returning call from the network 
     
    312276  protected: 
    313277 
    314     //      public boolean handlePullFromNet(PullCall mc) { 
    315     //          return super.pullValueRaw(mc, ThreadLocalCache.getFast()); 
    316     //      } 
    317     // 
    318     //      public void handleCallReturnFromNet(AbstractCall mc) { 
    319     //          super.handleCallReturn(mc); 
    320     //      } 
    321  
    322278    virtual void ConnectionRemoved(tAbstractPort* partner) 
    323279    { 
     
    366322    } 
    367323 
    368     //      @Override 
    369     //      public boolean pullValueRaw(PullCall call, ThreadLocalCache tc) { 
    370     //          if (isOutputPort()) { // pull to forward over the network? 
    371     //              assert(!call.isReturning(true)); 
    372     //              sendCall(call); 
    373     //              return false; 
    374     //          } else { // returning pull call 
    375     //              assert(call.isReturning(true)); 
    376     //              return super.pullValueRaw(call, tc); 
    377     //          } 
    378     //      } 
    379     // 
    380     //      @Override 
    381     //      public void handleCallReturn(AbstractCall call) { 
    382     //          if (isOutputPort()) { 
    383     //              assert(call.isReturning(true)); 
    384     //              super.handleCallReturn(call); 
    385     //          } else { 
    386     //              assert(!call.isReturning(true)); 
    387     //              NetPort.this.sendCallReturn(call); 
    388     //          } 
    389     //      } 
    390  
    391324    virtual bool PropagateStrategy(tAbstractPort* push_wanter, tAbstractPort* new_connection_partner); 
    392325 
    393     //      @Override 
    394     //      protected short getStrategyRequirement() { 
    395     //          if (isOutputPort()) { 
    396     //              return 0; // should be zero - since it's a proxy 
    397     //          } else { 
    398     //              return getStrategy(); 
    399     //          } 
    400     //      } 
    401  
    402326    void PropagateStrategy(int16 strategy); 
    403327 
     
    405329 
    406330    virtual void PullRequest(tCCPortBase* origin, void* result_buffer); 
    407  
    408     //      protected void setCallHandler(CallHandler ch) { 
    409     //          setCallHandler(ch); 
    410     //      } 
    411331 
    412332    inline void UpdateFlags(int flags) 
     
    431351  protected: 
    432352 
    433     //      public boolean handlePullFromNet(PullCall mc) { 
    434     //          return super.pullValueRaw(mc); 
    435     //      } 
    436     // 
    437     //      public void handleCallReturnFromNet(AbstractCall mc) { 
    438     //          SynchMethodCallLogic. 
    439     //      } 
    440  
    441353    virtual void ConnectionRemoved(tAbstractPort* partner) 
    442354    { 
     
    485397    } 
    486398 
    487     //      @Override 
    488     //      public boolean pullValueRaw(PullCall call) { 
    489     //          if (isOutputPort()) { // pull to forward over the network? 
    490     //              assert(!call.isReturning(true)); 
    491     //              sendCall(call); 
    492     //              return false; 
    493     //          } else { // returning pull call 
    494     //              assert(call.isReturning(true)); 
    495     //              return super.pullValueRaw(call); 
    496     //          } 
    497     //      } 
    498     // 
    499     //      @Override 
    500     //      public void handleCallReturn(AbstractCall call) { 
    501     //          if (isOutputPort()) { 
    502     //              assert(call.isReturning(true)); 
    503     //              super.handleCallReturn(call); 
    504     //          } else { 
    505     //              assert(!call.isReturning(true)); 
    506     //              NetPort.this.sendCallReturn(call); 
    507     //          } 
    508     //      } 
    509  
    510399    virtual bool PropagateStrategy(tAbstractPort* push_wanter, tAbstractPort* new_connection_partner); 
    511  
    512     //      @Override 
    513     //      protected short getStrategyRequirement() { 
    514     //          if (isOutputPort()) { 
    515     //              return 0; // should be zero - since it's a proxy 
    516     //          } else { 
    517     //              return getStrategy(); 
    518     //          } 
    519     //      } 
    520400 
    521401    inline void PropagateStrategy(int16 strategy) 
     
    550430  protected: 
    551431 
    552     //      @Override 
    553     //      protected boolean handleCall(MethodCall mc, boolean deferredCall) { 
    554     //          NetPort.this.handleCall(mc); 
    555     //          return false; 
    556     //      } 
    557     // 
    558     //      @Override 
    559     //      public void returnValue(MethodCall mc) { 
    560     //          super.returnValue(mc); 
    561     //      } 
    562     // 
    563     //      @Override 
    564     //      public void sendMethodCall(MethodCall mc) { 
    565     //          super.sendMethodCall(mc); 
    566     //      } 
    567     // 
    568     //      public void handleCallReturnFromNet(AbstractCall mc) { 
    569     //          SynchMethodCallLogic.handleMethodReturn(mc); 
    570     //      } 
    571     // 
    572     //      @Override 
    573     //      public void handleMethodCall(MethodCall mc, byte methodId, 
    574     //              boolean deferred, long int1, long int2, long int3, double dbl1, 
    575     //              double dbl2, double dbl3, TypedObject obj1, TypedObject obj2) { 
    576     //          assert(false) : "Programming error: should not be called"; 
    577     //      } 
    578  
    579432    virtual void ConnectionRemoved(tAbstractPort* partner) 
    580433    { 
     
    598451      outer_class_ptr->PreChildInit(); 
    599452    } 
    600  
    601     //      public void receiveDataFromStream(CoreInput ci) { 
    602     //          MethodCall mc = (MethodCall)ci.readObject(); 
    603     //          if (!mc.isReturning(true)) { 
    604     //              mc.pushCaller(belongsTo); 
    605     //              this.sendMethodCall(mc); 
    606     //          } else { 
    607     //              mc.returnToCaller(); 
    608     //          } 
    609     //      } 
    610  
    611     //      @Override 
    612     //      protected void setCallHandler(CallHandler ch) { 
    613     //          super.setCallHandler(ch); 
    614     //      } 
    615453 
    616454    virtual void PrepareDelete() 
     
    665503  }; 
    666504 
    667   /*! 
    668    * \return Sources of remote edges 
    669    */ 
    670   //@JavaOnly 
    671   //public abstract List<FrameworkElement> getRemoteEdgeSources(); 
    672  
    673505}; 
    674506 
  • port/rpc/method/tAbstractMethod.h

    r27 r57  
    140140  } 
    141141 
    142   // 
    143   //  bool hasLock(const PortData* pd) { 
    144   //      if (pd == NULL) { 
    145   //          return true; 
    146   //      } 
    147   //      return pd->getManager()->isLocked(); 
    148   //  } 
    149   // 
    150   //  bool hasLock(const CCPortData* cpd) { 
    151   //      if (cpd == NULL) { 
    152   //          return true; 
    153   //      } 
    154   //      return true; 
    155   //  } 
    156   // 
    157   //  inline bool hasLock(const int64 cpd) { 
    158   //      return true; 
    159   //  } 
    160   // 
    161   //  inline bool hasLock(const double cpd) { 
    162   //      return true; 
    163   //  } 
    164   // 
    165   //  inline bool hasLock(const int cpd) { 
    166   //      return true; 
    167   //  } 
    168   // 
    169   //  inline bool hasLock(const int16 cpd) { 
    170   //      return true; 
    171   //  } 
    172   // 
    173   //  inline bool hasLock(const int8 cpd) { 
    174   //      return true; 
    175   //  } 
    176   // 
    177   //  inline bool hasLock(const float cpd) { 
    178   //      return true; 
    179   //  } 
    180   // 
    181   //  template <typename T> 
    182   //  bool hasLock(const CCInterThreadContainer<T>* c) { 
    183   //      if (c == NULL) { 
    184   //          return true; 
    185   //      } 
    186   //      return true; 
    187   //  } 
    188   // 
    189   //  template <typename T> 
    190   //  inline bool hasLock(T t) { 
    191   //      return hasLock(static_cast<const T>(t)); 
    192   //  } 
    193   // 
    194   // 
    195   //  void cleanup(PortData* pd) { 
    196   //      if (pd == NULL) { 
    197   //          return; 
    198   //      } 
    199   //      pd->getManager()->releaseLock(); 
    200   //  } 
    201   // 
    202   //  void cleanup(const CCPortData* pd) {} 
    203   //  inline void cleanup(const int num) {} 
    204   //  inline void cleanup(const double num) {} 
    205   //  inline void cleanup(const int64 num) {} 
    206   //  inline void cleanup(const int16 num) {} 
    207   //  inline void cleanup(const int8 num) {} 
    208   //  inline void cleanup(const float num) {} 
    209   // 
    210   //  template <typename T> 
    211   //  void cleanup(const CCInterThreadContainer<T>* c) { 
    212   //      if (c == NULL) { 
    213   //          return; 
    214   //      } 
    215   //      c->recycle2(); 
    216   //  } 
    217   // 
    218   //  template <typename T> 
    219   //  inline void cleanup(T t) { 
    220   //      cleanup(static_cast<const T>(t)); 
    221   //  } 
    222   // 
    223  
    224142  inline bool HandleInExtraThread() 
    225143  { 
  • port/rpc/tAbstractCall.h

    r27 r57  
    171171  } 
    172172 
    173   // 
    174   //  void addParamForSending(const PortData* pd) { 
    175   //      if (pd == NULL) { 
    176   //          os.writeByte(NULLPARAM); 
    177   //      } 
    178   //      os.writeByte(PORTDATA); 
    179   //      responsibilities.add(pd); 
    180   //  } 
    181   // 
    182   //  void addParamForSending(const int pd) { 
    183   //      os.writeByte(INT); 
    184   //      os.writeInt(pd); 
    185   //  } 
    186   // 
    187   //  void addParamForSending(const int64 pd) { 
    188   //      os.writeByte(LONG); 
    189   //      os.writeLong(pd); 
    190   //  } 
    191   // 
    192   //  void addParamForSending(const float pd) { 
    193   //      os.writeByte(FLOAT); 
    194   //      os.writeFloat(pd); 
    195   //  } 
    196   // 
    197   //  void addParamForSending(const double pd) { 
    198   //      os.writeByte(DOUBLE); 
    199   //      os.writeDouble(pd); 
    200   //  } 
    201   // 
    202   //  void addParamForSending(const int8 pd) { 
    203   //      os.writeByte(BYTE); 
    204   //      os.writeByte(pd); 
    205   //  } 
    206   // 
    207   //  void addParamForSending(const short pd) { 
    208   //      os.writeByte(SHORT); 
    209   //      os.writeShort(pd); 
    210   //  } 
    211   // 
    212   // 
    213   //  template <typename T> 
    214   //  void addParamForSending(CCInterThreadContainer<T>* container) { 
    215   //      if (container == NULL) { 
    216   //          os.writeByte(NULLPARAM); 
    217   //      } 
    218   //      //assert(container->isInterThreadContainer() && "only interthread container allowed in method calls"); 
    219   //      os.writeByte(CCCONTAINER); 
    220   //      os.writeObject(container); 
    221   //      container->recycle2(); 
    222   //  } 
    223   // 
    224   //  template <typename T> 
    225   //  void addParamForSending(const T* c) { 
    226   //      if (c == NULL) { 
    227   //          os.writeByte(NULLPARAM); 
    228   //      } 
    229   //      DataType* dt = DataTypeRegister::getInstance()->getDataType<T>(); 
    230   //      assert(dt != NULL && dt->isCCType()); 
    231   //      os.writeByte(CCDATA); 
    232   //      os.writeShort(dt->getUid()); 
    233   //      writeParam(c, dt); 
    234   //  } 
    235   // 
    236   //  template <typename T> 
    237   //  void addParamForSending(T c) { 
    238   //      addParamForSending((const T)c); 
    239   //  } 
    240   // 
    241   //  void writeParam(const CoreSerializable* cs, DataType* dt) { 
    242   //      cs->serialize(os); 
    243   //  } 
    244   // 
    245   //  void writeParam(void* cs, DataType* dt) { 
    246   //      dt->directSerialize(cs, &os); 
    247   //  } 
    248   // 
    249   //  void addParamForLocalCall(int paramIndex, const PortData* pd) { 
    250   //      Parameter* p = &(params[paramIndex]); 
    251   //      if (pd == NULL) { 
    252   //          p->type = NULLPARAM; 
    253   //      } 
    254   //      p->type = PORTDATA; 
    255   //      p->value = pd; 
    256   //  } 
    257   // 
    258   //  void addParamForLocalCall(int paramIndex, const int pd) { 
    259   //      Parameter* p = &(params[paramIndex]); 
    260   //      p->type = INT; 
    261   //      p->ival = pd; 
    262   //  } 
    263   // 
    264   //  void addParamForLocalCall(int paramIndex, const int64 pd) { 
    265   //      Parameter* p = &(params[paramIndex]); 
    266   //      p->type = LONG; 
    267   //      p->lval = pd; 
    268   //  } 
    269   // 
    270   //  void addParamForLocalCall(int paramIndex, const float pd) { 
    271   //      Parameter* p = &(params[paramIndex]); 
    272   //      p->type = FLOAT; 
    273   //      p->fval = pd; 
    274   //  } 
    275   // 
    276   //  void addParamForLocalCall(int paramIndex, const double pd) { 
    277   //      Parameter* p = &(params[paramIndex]); 
    278   //      p->type = DOUBLE; 
    279   //      p->dval = pd; 
    280   //  } 
    281   // 
    282   //  void addParamForLocalCall(int paramIndex, const int8 pd) { 
    283   //      Parameter* p = &(params[paramIndex]); 
    284   //      p->type = BYTE; 
    285   //      p->bval = pd; 
    286   //  } 
    287   // 
    288   //  void addParamForLocalCall(int paramIndex, const int16 pd) { 
    289   //      Parameter* p = &(params[paramIndex]); 
    290   //      p->type = SHORT; 
    291   //      p->sval = pd; 
    292   //  } 
    293   // 
    294   //  template <typename T> 
    295   //  void addParamForLocalCall(int paramIndex, CCInterThreadContainer<T>* container) { 
    296   //      Parameter* p = &(params[paramIndex]); 
    297   //      if (container == NULL) { 
    298   //          p->type = NULLPARAM; 
    299   //      } 
    300   //      //assert(container->isInterThreadContainer() && "only interthread container allowed in method calls"); 
    301   //      p->ccval = container; 
    302   //  } 
    303   // 
    304   //  template <typename T> 
    305   //  void addParamForLocalCall(int paramIndex, const T* c) { 
    306   //      Parameter* p = &(params[paramIndex]); 
    307   //      if (c == NULL) { 
    308   //          p->type = NULLPARAM; 
    309   //      } 
    310   //      DataType* dt = DataTypeRegister::getInstance()->getDataType<T>(); 
    311   //      assert(dt != NULL && dt->isCCType()); 
    312   //      CCInterThreadContainer<T>* cc = (CCInterThreadContainer<T>*)GetInterThreadBuffer(dt); 
    313   //      cc->assign(c); 
    314   //      p->type = CCDATA; 
    315   //      p->ccval = cc; 
    316   //  } 
    317   // 
    318   //  template <typename T> 
    319   //  void addParamForLocalCall(int paramIndex, T c) { 
    320   //      addParamForLocalCall(paramIndex, (const T)c); 
    321   //  } 
    322   // 
    323  
    324173  /*! 
    325174   * Prepare method call received from the net for local call. 
     
    398247  } 
    399248 
    400   //  /** 
    401   //   * (Should only be called by network port) 
    402   //   * Add caller to top of caller stack 
    403   //   * 
    404   //   * \param callerHandle caller handle 
    405   //   */ 
    406   //  public void pushCaller(int callerHandle) { 
    407   //      callerStack.add(callerHandle); 
    408   //  } 
    409   // 
    410   //  /** 
    411   //   * (Should only be called by network port) 
    412   //   * Add caller to top of caller stack 
    413   //   * 
    414   //   * \param caller Caller 
    415   //   */ 
    416   //  public void pushCaller(FrameworkElement caller) { 
    417   //      callerStack.add(caller.getHandle()); 
    418   //  } 
    419   // 
    420   //  /** 
    421   //   * (Should only be called by network port) 
    422   //   * \return return current size of caller stack 
    423   //   */ 
    424   //  @ConstMethod public @SizeT int callerStackSize() { 
    425   //      return callerStack.size(); 
    426   //  } 
    427   // 
    428   //  /** 
    429   //   * (Should only be called by network port) 
    430   //   * Remove and return caller handle at top of stack 
    431   //   * 
    432   //   * \return Caller Handle 
    433   //   */ 
    434   //  public int popCaller() { 
    435   //      return callerStack.removeLast(); 
    436   //  } 
    437   // 
    438   //  /** 
    439   //   * Remove and return caller at top of stack 
    440   //   * 
    441   //   * \return Caller 
    442   //   */ 
    443   //  public FrameworkElement popCallerElement() { 
    444   //      return RuntimeEnvironment.getInstance().getElement(popCaller()); 
    445   //  } 
    446   // 
    447   //  /** 
    448   //   * Pop caller from stack and call its handleCallReturn method 
    449   //   */ 
    450   //  public void returnToCaller() { 
    451   //      FrameworkElement fe = popCallerElement(); 
    452   //      if (fe != null) { 
    453   //          fe.handleCallReturn(this); 
    454   //      } else { 
    455   //           printf("%p ", this); 
    456   //          System.out.println("warning: lost method call, because caller seems to have been deleted... caller will hopefully timeout(?)"); 
    457   //          //recycle(); 
    458   //      } 
    459   //  } 
    460  
    461249  virtual void Serialize(tCoreOutput& oos) const; 
    462  
    463   // 
    464   //  void getParam(int index, const PortData*& pd) { 
    465   //      Parameter* p = &(params[index]); 
    466   //      pd = p->value; 
    467   //      p->clear(); 
    468   //  } 
    469   // 
    470   //  void getParam(int index, PortData*& pd) { 
    471   //      Parameter* p = &(params[index]); 
    472   //      pd = const_cast<PortData*>(p->value); // not entirely clean... but everything else seems a lot of work (what's const and what isn't should be defined in methods) 
    473   //      p->clear(); 
    474   //  } 
    475   // 
    476   //  void getParam(int index, int& pd) { 
    477   //      Parameter* p = &(params[index]); 
    478   //      pd = p->ival; 
    479   //      p->clear(); 
    480   //  } 
    481   // 
    482   //  void getParam(int index, int64& pd) { 
    483   //      Parameter* p = &(params[index]); 
    484   //      pd = p->lval; 
    485   //      p->clear(); 
    486   //  } 
    487   // 
    488   //  void getParam(int index, float& pd) { 
    489   //      Parameter* p = &(params[index]); 
    490   //      pd = p->fval; 
    491   //      p->clear(); 
    492   //  } 
    493   // 
    494   //  void getParam(int index, double& pd) { 
    495   //      Parameter* p = &(params[index]); 
    496   //      pd = p->dval; 
    497   //      p->clear(); 
    498   //  } 
    499   // 
    500   //  void getParam(int index, int8& pd) { 
    501   //      Parameter* p = &(params[index]); 
    502   //      pd = p->bval; 
    503   //      p->clear(); 
    504   //  } 
    505   // 
    506   //  void getParam(int index, int16& pd) { 
    507   //      Parameter* p = &(params[index]); 
    508   //      pd = p->sval; 
    509   //      p->clear(); 
    510   //  } 
    511   // 
    512   //  template <typename T> 
    513   //  void getParam(int index, CCInterThreadContainer<T>*& container) { 
    514   //      Parameter* p = &(params[index]); 
    515   //      container = p->ccval; 
    516   //      p->clear(); 
    517   //  } 
    518   // 
    519   //  template <typename T> 
    520   //  void getParam(int index, T*& c) { 
    521   //      Parameter* p = &(params[index]); 
    522   //      c = p->ccval->getDataPtr(); 
    523   //      p->clear(); 
    524   //  } 
    525   // 
    526250 
    527251  /*! 
  • port/rpc/tInterfaceClientPort.h

    r27 r57  
    4040  /* implements ReturnHandler*/ 
    4141 
    42   ///** Return handler */ 
    43   //private ReturnHandler handler; 
    44  
    4542  tInterfaceClientPort(const util::tString& description, tFrameworkElement* parent, tDataType* type) : 
    4643      tInterfacePort(description, parent, type, ::finroc::core::tInterfacePort::eClient) 
     
    5855  } 
    5956 
    60 //  public InterfaceClientPort(String description, FrameworkElement parent, DataType type, ReturnHandler rh) { 
    61 //      super(description, parent, type, Type.Client); 
    62 //      setReturnHandler(rh); 
    63 //  } 
    64  
    65 //  /** 
    66 //   * \param rh ReturnHandler 
    67 //   */ 
    68 //  public void setReturnHandler(ReturnHandler rh) { 
    69 //      handler = rh; 
    70 //  } 
    71 // 
    72 //  @Override 
    73 //  public void handleMethodReturn(MethodCall mc, byte methodId, long intRet, double dblRet, TypedObject objRet) { 
    74 //      System.out.println("Unhandled asynchronous method reply: " + mc.toString()); 
    75 //  } 
    76  
    77 //  @Override 
    78 //  public void handleCallReturn(AbstractCall pc) { 
    79 //      returnValue((MethodCall)pc); 
    80 //  } 
    81 // 
    82 //  /** 
    83 //   * (low-level method - only use when you know what you're doing) 
    84 //   * 
    85 //   * Perform synchronous method call with parameters in 
    86 //   * specified method call buffer. 
    87 //   * Thread will be stuck inside this method until it 
    88 //   * returns. 
    89 //   * 
    90 //   * Caller is in charge of unlocking and therewith releasing MethodCall buffers 
    91 //   * 
    92 //   * \param mc Filled Method call buffer 
    93 //   * \param timeout Timeout in milliseconds 
    94 //   * \return Method call result - may be the same as parameter 
    95 //   */ 
    96 //  protected MethodCall synchMethodCall(MethodCall mc, long timeout) throws MethodCallException { 
    97 //      assert(isReady()); 
    98 //      mc.alreadyDeferred = false; 
    99 //      MethodCall ret = SynchMethodCallLogic.performSynchCall(mc, this, callIndex, timeout); 
    100 //      if (ret != null && ret.getStatus() == MethodCall.CONNECTION_EXCEPTION) { // not connected (?) 
    101 //          ret.autoRecycleRetVal = true; 
    102 //          ret.recycleComplete(); 
    103 //          throw new MethodCallException(false); 
    104 //      } 
    105 //      return ret; 
    106 //  } 
    107 // 
    108 //  /** 
    109 //   * This description is more or less valid for all methods in this class 
    110 //   * 
    111 //   * \param retValueType Type of return value (e.g. MethodCall.RETURN_INT) 
    112 //   * \param methodId Unambiguous method identification (defined by concrete server/client classes) 
    113 //   * \param int1 first integer parameter (optional - defined by concrete server/client classes) 
    114 //   * \param int2 second integer parameter (optional - defined by concrete server/client classes) 
    115 //   * \param int3 third integer parameter (optional - defined by concrete server/client classes) 
    116 //   * \param dbl1 first double parameter (optional - defined by concrete server/client classes) 
    117 //   * \param dbl2 second double parameter (optional - defined by concrete server/client classes) 
    118 //   * \param dbl3 third double parameter (optional - defined by concrete server/client classes) 
    119 //   * \param obj1 first object parameter (optional - defined by concrete server/client classes) 
    120 //   * \param lockedOrCopied1 Is object parameter 1 already locked/copied (and can be unlocked/recycled by this class) 
    121 //   * \param obj2 second object parameter (optional - defined by concrete server/client classes) 
    122 //   * \param lockedOrCopied2 Is object parameter 2 already locked/copied (and can be unlocked/recycled by this class) 
    123 //   * \param autoRecycleRet Should return value automatically be recycled (relevant for synchronized object calls only) 
    124 //   * @return 
    125 //   */ 
    126 //  @Inline protected MethodCall createCall(byte retValueType, byte methodId, long int1, long int2, long int3, double dbl1, double dbl2, double dbl3, 
    127 //          TypedObject obj1, boolean lockedOrCopied1, TypedObject obj2, boolean lockedOrCopied2, boolean autoRecycleRet) { 
    128 //      MethodCall mc = ThreadLocalCache.get().getUnusedMethodCall(); 
    129 //      mc.setupCall(retValueType, methodId, int1, int2, int3, dbl1, dbl2, dbl3, obj1, lockedOrCopied1, obj2, lockedOrCopied2); 
    130 //      mc.autoRecycleRetVal = autoRecycleRet; 
    131 //      mc.alreadyDeferred = false; 
    132 //      return mc; 
    133 //  } 
    134 // 
    135 //  public long synchIntMethodCall(byte methodId, long int1, long int2, long int3, double dbl1, double dbl2, double dbl3, 
    136 //          TypedObject obj1, boolean lockedOrCopied1, TypedObject obj2, boolean lockedOrCopied2, long timeout) throws MethodCallException { 
    137 //      MethodCall mc = createCall(MethodCall.RETURN_INT, methodId, int1, int2, int3, dbl1, dbl2, dbl3, obj1, lockedOrCopied1, obj2, lockedOrCopied2, false); 
    138 //      //try { 
    139 //      mc = synchMethodCall(mc, timeout); 
    140 //      long ret = mc.getReturnInt(); 
    141 //      mc.recycleComplete(); 
    142 //      return ret; 
    143 //      //} catch (MethodCallException e) { 
    144 //      //  mc.genericRecycle(); 
    145 //      //  throw e; 
    146 //      //} 
    147 //  } 
    148 //  public double synchDoubleMethodCall(byte methodId, long int1, long int2, long int3, double dbl1, double dbl2, double dbl3, 
    149 //          TypedObject obj1, boolean lockedOrCopied1, TypedObject obj2, boolean lockedOrCopied2, long timeout) throws MethodCallException { 
    150 //      MethodCall mc = createCall(MethodCall.RETURN_DOUBLE, methodId, int1, int2, int3, dbl1, dbl2, dbl3, obj1, lockedOrCopied1, obj2, lockedOrCopied2, false); 
    151 //      //try { 
    152 //      mc = synchMethodCall(mc, timeout); 
    153 //      double ret = mc.getReturnDouble(); 
    154 //      mc.recycleComplete(); 
    155 //      return ret; 
    156 //      //} catch (MethodCallException e) { 
    157 //      //  //mc.genericRecycle(); 
    158 //      //  throw e; 
    159 //      //} 
    160 //  } 
    161 //  public TypedObject synchObjMethodCall(byte methodId, long int1, long int2, long int3, double dbl1, double dbl2, double dbl3, 
    162 //          TypedObject obj1, boolean lockedOrCopied1, TypedObject obj2, boolean lockedOrCopied2, long timeout, boolean autoRecycleRet) throws MethodCallException { 
    163 //      MethodCall mc = createCall(MethodCall.RETURN_OBJ, methodId, int1, int2, int3, dbl1, dbl2, dbl3, obj1, lockedOrCopied1, obj2, lockedOrCopied2, autoRecycleRet); 
    164 //      //try { 
    165 //      mc = synchMethodCall(mc, timeout); 
    166 //      TypedObject ret = mc.getReturnObject(); 
    167 //      if (mc.autoRecycleRetVal) { 
    168 //          ThreadLocalCache.get().addAutoLock(ret); 
    169 //          mc.autoRecycleRetVal = false; 
    170 //      } 
    171 //      mc.recycleComplete(); 
    172 //      return ret; 
    173 //      //} catch (MethodCallException e) { 
    174 //      //  //mc.genericRecycle(); 
    175 //      //  throw e; 
    176 //      //} 
    177 //  } 
    178 // 
    179 //  public void asynchMethodCall(byte retValueType, byte methodId, long int1, long int2, long int3, double dbl1, double dbl2, double dbl3, 
    180 //          TypedObject obj1, boolean lockedOrCopied1, TypedObject obj2, boolean lockedOrCopied2) { 
    181 //      super.asynchMethodCall(createCall(retValueType, methodId, int1, int2, int3, dbl1, dbl2, dbl3, obj1, lockedOrCopied1, obj2, lockedOrCopied2, true)); 
    182 //  } 
    183 // 
    184 //  // Various wrappers for the above 
    185 //  public void asynchMethodCall(byte retValueType, byte methodId, long int1, TypedObject obj1, boolean lockedOrCopied1) { 
    186 //      asynchMethodCall(retValueType, methodId, int1, 0, 0, 0, 0, 0, obj1, lockedOrCopied1, null, false); 
    187 //  } 
    188 //  public TypedObject synchObjMethodCall(byte methodId, long int1, long int2, long int3, long timeout, boolean autoRecycleRet) throws MethodCallException { 
    189 //      return synchObjMethodCall(methodId, int1, int2, int3, 0, 0, 0, null, true, null, true, timeout, autoRecycleRet); 
    190 //  } 
    191 //  public void asynchMethodCall(byte retValueType, byte methodId, TypedObject obj1, boolean lockedOrCopied1) { 
    192 //      asynchMethodCall(retValueType, methodId, 0, 0, 0, 0, 0, 0, obj1, lockedOrCopied1, null, false); 
    193 //  } 
    194 //  public TypedObject synchObjMethodCall(byte methodId, long timeout, boolean autoRecycleRet) throws MethodCallException { 
    195 //      return synchObjMethodCall(methodId, 0, 0, 0, timeout, autoRecycleRet); 
    196 //  } 
    197 //  public long synchIntMethodCall(byte methodId, long timeout) throws MethodCallException { 
    198 //      return synchIntMethodCall(methodId, 0, 0, 0, 0, 0, 0, null, false, null, false, timeout); 
    199 //  } 
    200  
    20157}; 
    20258 
  • port/rpc/tInterfacePort.h

    r27 r57  
    7070public: 
    7171 
    72   //  /** Does port handle method calls? In this case this points to the class that will handle the method calls */ 
    73   //  private CallHandler callHandler; 
    74   // 
    75   //  /** Does port accept return values from asynchronous method calls? In this case, this points to the class that will handle them */ 
    76   //  private ReturnHandler returnHandler; 
    77  
    7872  /*! Pool with diverse data buffers */ 
    7973  tMultiTypePortDataBufferPool* buf_pool; 
     
    146140  } 
    147141 
    148   //  /** 
    149   //   * (low-level method - only use when you know what you're doing) 
    150   //   * 
    151   //   * Perform asynchronous method call with parameters in 
    152   //   * specified method call buffer. 
    153   //   * 
    154   //   * MethodCall buffer will be unlocked and recycled by receiver 
    155   //   * 
    156   //   * \param mc Filled Method call buffer 
    157   //   * \return Method call result - may be the same as parameter 
    158   //   */ 
    159   //  protected void asynchMethodCall(MethodCall mc) { 
    160   //      mc.setupAsynchCall(); 
    161   //      mc.pushCaller(this); 
    162   //      mc.alreadyDeferred = false; 
    163   //      sendMethodCall(mc); 
    164   //  } 
    165   // 
    166   //  /** 
    167   //   * Return from synchronous method call 
    168   //   * 
    169   //   * \param mc Method call data 
    170   //   */ 
    171   //  @NonVirtual protected void returnValue(MethodCall mc) { 
    172   //      if (mc.callerStackSize() > 0) { 
    173   // 
    174   //          // return value to network port 
    175   //          mc.returnToCaller(); 
    176   // 
    177   //      } else if (mc.getStatus() == MethodCall.SYNCH_RETURN || mc.getStatus() == MethodCall.CONNECTION_EXCEPTION) { 
    178   // 
    179   //          SynchMethodCallLogic.handleMethodReturn(mc); 
    180   // 
    181   //      } else if (mc.getStatus() == MethodCall.ASYNCH_RETURN) { 
    182   // 
    183   //          handleAsynchReturn(mc, false); 
    184   //      } 
    185   //  } 
    186   // 
    187   //  // These methods should typically not be called by subclasses 
    188   // 
    189   //  /** 
    190   //   * Receive method call (synch and asynch) - either forward or handle it 
    191   //   * 
    192   //   * \param mc Method call 
    193   //   */ 
    194   //  @Inline 
    195   //  protected void receiveMethodCall(MethodCall mc) { 
    196   //      if (callHandler != null) { 
    197   //          handleCall(mc, false); 
    198   //      } else { 
    199   //          sendMethodCall(mc); 
    200   //      } 
    201   //  } 
    202   // 
    203   //  /** 
    204   //   * Handle method call (current or deferred) 
    205   //   * 
    206   //   * \param mc Method call 
    207   //   * \param deferredCall Is this a deferred call? 
    208   //   * \return Was call deferred? 
    209   //   */ 
    210   //  protected boolean handleCall(MethodCall mc, boolean deferredCall) { 
    211   //      mc.autoRecycleTParam1 = true; 
    212   //      mc.autoRecycleTParam2 = true; 
    213   //      //mc.curServerPort = this; 
    214   //      mc.returnValueSet = false; 
    215   //      mc.defer = false; 
    216   //      mc.call(callHandler, deferredCall); 
    217   //      if (!mc.defer) { 
    218   //          if (mc.rType == MethodCall.NONE) { 
    219   //              mc.recycleComplete(); 
    220   //              assert(!mc.returnValueSet); 
    221   //          } else { 
    222   //              mc.recycleParams(); 
    223   //              assert(mc.returnValueSet); 
    224   //              mc.setStatus(mc.getStatus() == MethodCall.SYNCH_CALL ? MethodCall.SYNCH_RETURN : MethodCall.ASYNCH_RETURN); 
    225   //              returnValue(mc); 
    226   //          } 
    227   //      } 
    228   //      return mc.defer; 
    229   //  } 
    230   // 
    231   //  /** 
    232   //   * Handle method call (current or deferred) 
    233   //   * 
    234   //   * \param mc Method call 
    235   //   * \param deferredCall Deferred return call 
    236   //   * \return Was call deferred? 
    237   //   */ 
    238   //  protected boolean handleAsynchReturn(MethodCall mc, boolean deferredCall) { 
    239   //      mc.autoRecycleRetVal = true; 
    240   //      //mc.curServerPort = this; 
    241   //      mc.defer = false; 
    242   //      returnHandler.handleMethodReturn(mc, mc.getMethodID(), mc.ri, mc.rd, mc.rt); 
    243   //      if (mc.defer) { 
    244   //          assert(mc.returnValueSet == false); 
    245   //      } else { 
    246   //          mc.recycleComplete(); 
    247   //      } 
    248   //      return mc.defer; 
    249   //  } 
    250   // 
    251   //  /** 
    252   //   * Send/forward method call (synch and asynch) 
    253   //   * 
    254   //   * \param mc Method call data 
    255   //   */ 
    256   //  @NonVirtual protected void sendMethodCall(MethodCall mc) { 
    257   //      @Ptr ArrayWrapper<InterfacePort> it = edgesDest.getIterable(); 
    258   //      for (@SizeT int i = 0, n = it.size(); i < n; i++) { 
    259   //          InterfacePort ip = (InterfacePort)it.get(i); 
    260   //          if (ip != null) { 
    261   //              ip.receiveMethodCall(mc); 
    262   //              return; 
    263   //          } 
    264   //      } 
    265   // 
    266   //      // return NULL if not connected 
    267   //      if (mc.getStatus() == MethodCall.SYNCH_CALL) { 
    268   //          mc.setStatus(MethodCall.CONNECTION_EXCEPTION); 
    269   //          mc.autoRecycleTParam1 = true; 
    270   //          mc.autoRecycleTParam2 = true; 
    271   //          mc.recycleParams(); 
    272   //          returnValue(mc); 
    273   //      } else { 
    274   //          mc.genericRecycle(); 
    275   //      } 
    276   //  } 
    277  
    278142  /*! 
    279143   * (for non-cc types only) 
     
    294158  } 
    295159 
    296   //  protected void setReturnHandler(ReturnHandler rh) { 
    297   //      assert(returnHandler == null); 
    298   //      returnHandler = rh; 
    299   //  } 
    300   // 
    301   //  protected void setCallHandler(CallHandler ch) { 
    302   //      assert(callHandler == null); 
    303   //      callHandler = ch; 
    304   //  } 
    305  
    306160  virtual void NotifyDisconnect()    /* don't do anything here... only in network ports */ 
    307161  { 
    308162  } 
    309  
    310   //  @Override 
    311   //  public TypedObject universalGetAutoLocked() { 
    312   //      System.out.println("warning: cannot get current value from interface port"); 
    313   //      return null; 
    314   //  } 
    315  
    316   //  @Override 
    317   //  public void invokeCall(MethodCall call) { 
    318   //      call.pushCaller(this); 
    319   //      sendMethodCall(call); 
    320   //  } 
    321163 
    322164  virtual void SetMaxQueueLength(int length) 
  • port/rpc/tMethodCall.cpp

    r26 r57  
    4242    source_net_port(NULL) 
    4343{ 
    44   //System.out.println("New method call"); 
    45  
    46   // type = cMETHOD_TYPE; 
    47  
    48   //tParams[0] = null; 
    49   //tParams[1] = null; 
    5044} 
    5145 
     
    5852  net_timeout = is->ReadInt(); 
    5953  ::finroc::core::tAbstractCall::DeserializeImpl(is, skip_parameters); 
    60   //      methodID = is.readByte(); 
    61   //      autoRecycleRetVal = is.readBoolean(); 
    62   //      byte mask = 0; 
    63   //      switch(status) { 
    64   //      case SYNCH_CALL: 
    65   //      case ASYNCH_CALL: 
    66   //          mask = is.readByte(); 
    67   //          tCount = (byte)((mask >> 6) & 3); 
    68   //          iCount = (byte)((mask >> 4) & 3); 
    69   //          dCount = (byte)((mask >> 2) & 3); 
    70   //          rType = (byte)(mask & 3); 
    71   //          for (int i = 0; i < tCount; i++) { 
    72   //              tParams[i] = readObject(is); 
    73   //          } 
    74   //          for (int i = 0; i < iCount; i++) { 
    75   //              iParams[i] = is.readLong(); 
    76   //          } 
    77   //          for (int i = 0; i < dCount; i++) { 
    78   //              dParams[i] = is.readLong(); 
    79   //          } 
    80   //          break; 
    81   //      case ASYNCH_RETURN: 
    82   //      case SYNCH_RETURN: 
    83   //          rType = is.readByte(); 
    84   //          assert(rType != NONE); 
    85   //          ri = is.readLong(); 
    86   //          rd = is.readDouble(); 
    87   //          rt = readObject(is); 
    88   //          break; 
    89   //      case CONNECTION_EXCEPTION: 
    90   //          break; 
    91   //      } 
    92   // 
    93   //      // reset some values 
    94   //      arrivalTime = 0; 
    95   //      alreadyDeferred = false; 
    9654} 
    9755 
     
    183141  oos.WriteInt(net_timeout); 
    184142  ::finroc::core::tAbstractCall::Serialize(oos); 
    185  
    186   //      oos.writeBoolean(autoRecycleRetVal); 
    187   //      byte mask = 0; 
    188   //      switch(status) { 
    189   //      case SYNCH_CALL: 
    190   //      case ASYNCH_CALL: 
    191   //          mask = (byte)((tCount << 6) | (iCount << 4) | (dCount << 2) | rType); 
    192   //          oos.writeByte(mask); 
    193   //          for (int i = 0; i < tCount; i++) { 
    194   //              oos.writeObject(tParams[i]); 
    195   //          } 
    196   //          for (int i = 0; i < iCount; i++) { 
    197   //              oos.writeLong(iParams[i]); 
    198   //          } 
    199   //          for (int i = 0; i < dCount; i++) { 
    200   //              oos.writeDouble(dParams[i]); 
    201   //          } 
    202   //          break; 
    203   //      case ASYNCH_RETURN: 
    204   //      case SYNCH_RETURN: 
    205   //          oos.writeByte(rType); 
    206   //          assert(rType != NONE); 
    207   //          // TODO optimize 
    208   //          oos.writeLong(ri); 
    209   //          oos.writeDouble(rd); 
    210   //          oos.writeObject(rt); 
    211   //          break; 
    212   //      case CONNECTION_EXCEPTION: 
    213   //          break; 
    214   //      } 
    215143} 
    216144 
  • port/rpc/tMethodCall.h

    r27 r57  
    5656private: 
    5757 
    58   //  /** Maximum size of caller stack */ 
    59   //  private final static int MAX_CALL_DEPTH = 4; 
    60   // 
    61   //  //private final TypedObject[] ccBufferRepository; 
    62   // 
    63   //  /** Parameters */ 
    64   //  private byte tCount, iCount, dCount; // number of parameters of each type 
    65   //  @InCpp("TypedObject* tParams[2];") 
    66   //  private final TypedObject[] tParams = new TypedObject[2]; 
    67   //  @InCpp("int64 iParams[3];") 
    68   //  private final long[] iParams = new long[3]; 
    69   //  @InCpp("double dParams[3];") 
    70   //  private final double[] dParams = new double[3]; 
    71   // 
    72   //  /** Type of return value */ 
    73   //  public static final byte RETURN_OBJ = 1, RETURN_INT = 2, RETURN_DOUBLE = 3; 
    74   //  protected byte rType; 
    75   // 
    76   //  /** Return value - depending on type */ 
    77   //  protected TypedObject rt; // either PortData or CCInterthreadContainer 
    78   //  protected long ri; 
    79   //  protected double rd; 
    80  
    81   //  /** method ID of call */ 
    82   //  private byte methodID; 
    83  
    84   //  /** Data type of method */ 
    85   //  public static DataType METHOD_TYPE; 
    86  
    87   // Temporary data for processing and checking requests - no need to transfer over the network 
    88   /*! Server port that processes current request */ 
    89   //InterfacePort curServerPort; 
    90  
    91   //  /** Has return value been set by server port? */ 
    92   //  boolean returnValueSet; 
    93   // 
    94   //  /** Automatically recycle these objects after call/return? */ 
    95   //  boolean autoRecycleTParam1, autoRecycleTParam2, autoRecycleRetVal; 
    96   // 
    97   //  /** Defer method call? */ 
    98   //  boolean defer; 
    99   // 
    100   //  /** Has method call been deferred at least once? */ 
    101   //  boolean alreadyDeferred; 
    102   // 
    103   //  /** Time when method call arrived - optional */ 
    104   //  private long arrivalTime; 
    105  
    106   //  public static void staticInit() { 
    107   //      // JavaOnlyBlock 
    108   //      METHOD_TYPE = DataTypeRegister.getInstance().addDataType(MethodCall.class); 
    109   // 
    110   //       cMETHOD_TYPE = tDataTypeRegister::GetInstance()->AddDataType<tMethodCall>("MethodCall"); 
    111   //  } 
    112  
    11358  /*! Method that is called */ 
    11459  tAbstractMethod* method; 
     
    165110  virtual void ExecuteTask(); 
    166111 
    167   //  /** 
    168   //   * Read object from strem 
    169   //   * (helper method for convenience - ensures that object has a lock) 
    170   //   * 
    171   //   * \param ci Input stream 
    172   //   */ 
    173   //  public TypedObject readObject(CoreInput ci) { 
    174   //      TypedObject result = ci.readObjectInInterThreadContainer(); 
    175   //      if (result != null && result.getType().isStdType()) { 
    176   //          ((PortData)result).getManager().getCurrentRefCounter().setLocks((byte)1); 
    177   //      } 
    178   //      return result; 
    179   //  } 
    180  
    181   //  /** 
    182   //   * (for call-handler) don't unlock/recycle parameter 1 
    183   //   */ 
    184   //  public void dontRecycleParam1() { 
    185   //      autoRecycleTParam1 = false; 
    186   //  } 
    187   // 
    188   //  /** 
    189   //   * (for call-handler) don't unlock/recycle parameter 2 
    190   //   */ 
    191   //  public void dontRecycleParam2() { 
    192   //      autoRecycleTParam2 = false; 
    193   //  } 
    194   // 
    195   //  /** 
    196   //   * (for return handler) don't recycle return value 
    197   //   */ 
    198   //  public void dontRecycleReturnValue() { 
    199   //      autoRecycleRetVal = false; 
    200   //  } 
    201   // 
    202   //  @Inline void deferCall(boolean logArrivalTime) { 
    203   //      if (logArrivalTime && (!alreadyDeferred)) { 
    204   //          setArrivalTime(); 
    205   //      } 
    206   //      defer = true; 
    207   //      alreadyDeferred = true; 
    208   //  } 
    209   // 
    210   //  /** 
    211   //   * Recycle/unlock parameters (provided they are not set not to be recycled) 
    212   //   */ 
    213   //  void recycleParams() { 
    214   //      if (autoRecycleTParam1) { 
    215   //          recycleParam(tParams[0]); 
    216   //      } 
    217   //      tParams[0] = null; 
    218   //      if (autoRecycleTParam2) { 
    219   //          recycleParam(tParams[1]); 
    220   //      } 
    221   //      tParams[1] = null; 
    222   //  } 
    223   // 
    224   //  private void recycleParam(@Ptr TypedObject p) { 
    225   //      if (p == null) { 
    226   //          return; 
    227   //      } 
    228   //      if (p.getType().isCCType()) { 
    229   //          ((CCInterThreadContainer<?>)p).recycle2(); 
    230   //      } else { 
    231   //          ((PortData)p).getManager().getCurrentRefCounter().releaseLock(); 
    232   //      } 
    233   //  } 
    234   // 
    235   //  /** 
    236   //   * Recycle everything... regardless over whether it has been set not to be recycled 
    237   //   * (should only be called by network ports) 
    238   //   */ 
    239   //  @Override 
    240   //  public void genericRecycle() { 
    241   //      if (isResponsible()) { 
    242   //          recycleParam(tParams[0]); 
    243   //          recycleParam(tParams[1]); 
    244   //          recycleParam(rt); 
    245   //          tParams[0] = null; 
    246   //          tParams[1] = null; 
    247   //          rt = null; 
    248   //          super.recycle(); 
    249   //      } 
    250   //  } 
    251   // 
    252   //  /** 
    253   //   * Recycle method call and recycle/unlock any objects (provided they are not set not to be recycled) 
    254   //   */ 
    255   //  void recycleComplete() { 
    256   //      recycleParams(); 
    257   //      if (autoRecycleRetVal) { 
    258   //          recycleParam(rt); 
    259   //      } 
    260   //      rt = null; 
    261   //      super.recycle(); 
    262   //  } 
    263  
    264   //  @Inline 
    265   //  protected void setupCall(byte retValueType, byte methodId2, long int1, long int2, long int3, double dbl1, double dbl2, double dbl3, TypedObject obj1, boolean lockedOrCopied1, TypedObject obj2, boolean lockedOrCopied2) { 
    266   //      // parameters 
    267   //      methodID = methodId2; 
    268   //      iCount = (byte)(int1 == 0 ? 0 : (int2 == 0 ? 1 : (int3 == 0 ? 2 : 3))); 
    269   //      dCount = (byte)(dbl1 == 0 ? 0 : (dbl2 == 0 ? 1 : (dbl3 == 0 ? 2 : 3))); 
    270   //      tCount = (byte)(obj1 == null ? 0 : (obj2 == null ? 1 : 2)); 
    271   //      iParams[0] = int1; 
    272   //      iParams[1] = int2; 
    273   //      iParams[2] = int3; 
    274   //      dParams[0] = dbl1; 
    275   //      dParams[1] = dbl2; 
    276   //      dParams[2] = dbl3; 
    277   //      setTParam(0, obj1, lockedOrCopied1); 
    278   //      setTParam(1, obj2, lockedOrCopied2); 
    279   // 
    280   //      // return values 
    281   //      ri = 0; 
    282   //      rd = 0; 
    283   //      rt = null; 
    284   // 
    285   //      // other stuff 
    286   //      rType = retValueType; 
    287   //      arrivalTime = 0; 
    288   //  } 
    289   // 
    290   //  private void setTParam(@SizeT int i, @Ptr TypedObject obj, boolean lockedOrCopied) { 
    291   //      if (obj != null) { 
    292   //          if (!obj.getType().isCCType()) { 
    293   //              PortData tmp = (PortData)obj; 
    294   //              if (!lockedOrCopied) { 
    295   //                  tmp.getCurReference().getRefCounter().setOrAddLock(); 
    296   //              } else { 
    297   //                  assert(tmp.getCurReference().getRefCounter().isLocked()); 
    298   //              } 
    299   //          } else { // cc type 
    300   //              @Ptr CCContainerBase cb = (CCContainerBase)obj; 
    301   //              if (cb.isInterThreadContainer()) { 
    302   //                  @Ptr CCInterThreadContainer<?> ic = (CCInterThreadContainer<?>)cb; 
    303   //                  if (!lockedOrCopied) { 
    304   //                      @Ptr CCInterThreadContainer<?> citc = ThreadLocalCache.get().getUnusedInterThreadBuffer(obj.getType()); 
    305   //                      citc.assign(ic.getDataPtr()); 
    306   //                      obj = citc; 
    307   //                  } 
    308   //              } else { 
    309   //                  @Ptr CCPortDataContainer<?> ic = (CCPortDataContainer<?>)cb; 
    310   //                  @Ptr CCInterThreadContainer<?> citc = ThreadLocalCache.get().getUnusedInterThreadBuffer(obj.getType()); 
    311   //                  citc.assign(ic.getDataPtr()); 
    312   //                  obj = citc; 
    313   //              } 
    314   //          } 
    315   //      } 
    316   //      tParams[i] = obj; 
    317   //  } 
    318   // 
    319   //  /** 
    320   //   * \return Integer return value 
    321   //   */ 
    322   //  protected long getReturnInt() { 
    323   //      assert(rType == RETURN_INT); 
    324   //      return ri; 
    325   //  } 
    326   // 
    327   //  /** 
    328   //   * \return Double return value 
    329   //   */ 
    330   //  protected double getReturnDouble() { 
    331   //      assert(rType == RETURN_DOUBLE); 
    332   //      return rd; 
    333   //  } 
    334   // 
    335   //  /** 
    336   //   * \return Object return value (locked) 
    337   //   */ 
    338   //  protected TypedObject getReturnObject() { 
    339   //      assert(rType == RETURN_OBJ); 
    340   //      return rt; 
    341   //  } 
    342   // 
    343   //  /** 
    344   //   * \param r Integer return value 
    345   //   */ 
    346   //  public void setReturn(int r) { 
    347   //      assert(rType == RETURN_INT); 
    348   //      returnValueSet = true; 
    349   //      ri = r; 
    350   //  } 
    351   // 
    352   //  /** 
    353   //   * \param r Double return value 
    354   //   */ 
    355   //  public void setReturn(double r) { 
    356   //      assert(rType == RETURN_DOUBLE); 
    357   //      returnValueSet = true; 
    358   //      rd = r; 
    359   //  } 
    360   // 
    361   //  /** 
    362   //   * Return null value 
    363   //   */ 
    364   //  public void setReturnNull() { 
    365   //      assert(rType == RETURN_OBJ); 
    366   //      returnValueSet = true; 
    367   //      rt = null; 
    368   //  } 
    369   // 
    370   //  /** 
    371   //   * \param r Object return value (locked) 
    372   //   * \param locked Has return value already been locked? (so that it can be automatically unlocked by this class) 
    373   //   */ 
    374   //  public void setReturn(PortData obj, boolean locked) { 
    375   //      assert(rType == RETURN_OBJ); 
    376   //      returnValueSet = true; 
    377   //      rt = obj; 
    378   //      if (obj == null) { 
    379   //          return; 
    380   //      } 
    381   //      if (!locked) { 
    382   //          obj.getCurReference().getRefCounter().setOrAddLock(); 
    383   //      } else { 
    384   //          assert(obj.getCurReference().getRefCounter().isLocked()); 
    385   //      } 
    386   //  } 
    387   // 
    388   //  /** 
    389   //   * \param obj Object return value (will be copied) 
    390   //   */ 
    391   //  public void setReturn(CCPortDataContainer<?> obj) { 
    392   //      assert(rType == RETURN_OBJ); 
    393   //      if (obj == null) { 
    394   //          setReturnNull(); 
    395   //          return; 
    396   //      } 
    397   //      CCInterThreadContainer<?> citc = ThreadLocalCache.get().getUnusedInterThreadBuffer(obj.getType()); 
    398   //      citc.assign(obj.getDataPtr()); 
    399   //      setReturn(citc, true); 
    400   //  } 
    401   // 
    402   //  /** 
    403   //   * \param obj Object return value 
    404   //   * \param extraCopy Is this already an extra copy that can be recycled automatically? 
    405   //   */ 
    406   //  public void setReturn(CCInterThreadContainer<?> obj, boolean extraCopy) { 
    407   //      assert(rType == RETURN_OBJ); 
    408   //      returnValueSet = true; 
    409   //      if (obj == null) { 
    410   //          rt = null; 
    411   //          return; 
    412   //      } 
    413   //      if (!extraCopy) { 
    414   //          CCInterThreadContainer<?> citc = ThreadLocalCache.get().getUnusedInterThreadBuffer(obj.getType()); 
    415   //          citc.assign(obj.getDataPtr()); 
    416   //          rt = citc; 
    417   //      } else { 
    418   //          rt = obj; 
    419   //      } 
    420   //  } 
    421   // 
    422   //  /** 
    423   //   * Perform method call on specified call handler 
    424   //   * 
    425   //   * \param callHandler Call Handler 
    426   //   * \param deferred Is this a deferred call? 
    427   //   */ 
    428   //  @Inline public void call(CallHandler callHandler, boolean deferred) { 
    429   //      callHandler.handleMethodCall(this, methodID, deferred, iParams[0], iParams[1], iParams[2], dParams[0], dParams[1], dParams[2], tParams[0], tParams[1]); 
    430   //  } 
    431   // 
    432   //  /** 
    433   //   * \return the arrivalTime 
    434   //   */ 
    435   //  public long getArrivalTime() { 
    436   //      return arrivalTime; 
    437   //  } 
    438   // 
    439   //  /** 
    440   //   * \param arrivalTime the arrivalTime to set 
    441   //   */ 
    442   //  public void setArrivalTime() { 
    443   //      if (arrivalTime == 0) { 
    444   //          arrivalTime = Time.getCoarse(); 
    445   //      } 
    446   //  } 
    447   // 
    448   //  /** 
    449   //   * \param arrivalTime the arrivalTime to set 
    450   //   */ 
    451   //  public void setArrivalTime(long time) { 
    452   //      arrivalTime = time; 
    453   //  } 
    454  
    455112  virtual void GenericRecycle() 
    456113  { 
    457114    Recycle(); 
    458115  } 
    459  
    460   //  @Override @JavaOnly 
    461   //  public DataType getType() { 
    462   //      return METHOD_TYPE; 
    463   //  } 
    464116 
    465117  /*! 
  • port/rpc/tMethodCallSyncher.h

    r27 r57  
    155155  } 
    156156 
    157   //  /** 
    158   //   * Pause thread until return value arrives 
    159   //   * 
    160   //   * \param timeout time to wait for return value 
    161   //   * @throws InterruptedException thrown as soon as return value arrived 
    162   //   */ 
    163   //  public void waitForReturnValue(long timeout) throws InterruptedException { 
    164   //      //System.out.println("Thread " + Thread.currentThread().toString() + " waiting for return value"); 
    165   //      Thread.sleep(timeout); 
    166   //      synchronized(this) { 
    167   //          threadWaitingForReturn = false; 
    168   //      } 
    169   //  } 
    170  
    171157  /*! 
    172158   * Return value arrives 
  • port/rpc/tPullCall.cpp

    r27 r57  
    9595} 
    9696 
    97 void tPullCall::Reset() 
    98 { 
    99   RecycleParameters(); 
    100   //      data = null; 
    101   //      ccData = null; 
    102   //      info.curRef = null; 
    103   //      info.curRefCounter = null; 
    104   //      info.lockEstimate = 5; 
    105   //      info.setLocks = 1; 
    106   //      tc = null; 
    107 } 
    108  
    10997void tPullCall::Serialize(tCoreOutput& oos) const 
    11098{ 
     
    112100  oos.WriteBoolean(intermediate_assign); 
    113101  oos.WriteBoolean(cc_pull); 
    114   //      if (isReturning(true)) { 
    115   //          oos.writeObject(ccPull ? (TypedObject)data : (TypedObject)info.curRef.getManager().getData()); 
    116   //      } 
    117102} 
    118103 
  • port/rpc/tPullCall.h

    r27 r57  
    4747public: 
    4848 
    49   //  /** Maximum size of caller stack */ 
    50   //  private final static int MAX_CALL_DEPTH = 16; 
    51  
    52   //  /** Data type of method */ 
    53   //  public static DataType METHOD_TYPE; 
    54  
    55   //  /** Stores information about pulled port data */ 
    56   //  public final @PassByValue PublishCache info = new PublishCache(); 
    57   // 
    58   //  /** Reference to pulled "cheap copy" port data */ 
    59   //  public CCInterThreadContainer<?> ccData; 
    60   // 
    61   //  /** Reference to pulled port data */ 
    62   //  public PortData data; 
    63   // 
    64   //  /** ThreadLocalCache - is != null - if it has been set up to perform assignments with current cc data */ 
    65   //  public ThreadLocalCache tc; 
    66  
    6749  /*! Assign pulled value to ports in between? */ 
    6850  bool intermediate_assign; 
     
    7961private: 
    8062 
    81   //  public static void staticInit() { 
    82   //      // JavaOnlyBlock 
    83   //      METHOD_TYPE = DataTypeRegister.getInstance().addDataType(MethodCall.class); 
    84   // 
    85   //       cMETHOD_TYPE = tDataTypeRegister::GetInstance()->AddDataType<tMethodCall>("MethodCall"); 
    86   //  } 
    87   // 
    88   //  @Override @JavaOnly 
    89   //  public DataType getType() { 
    90   //      return METHOD_TYPE; 
    91   //  } 
    92  
    9363  /*! 
    9464   * Reset all variable in order to reuse object 
    9565   */ 
    96   void Reset(); 
     66  inline void Reset() 
     67  { 
     68    RecycleParameters(); 
     69  } 
    9770 
    9871public: 
     
    10073  tPullCall(); 
    10174 
    102   //  /** 
    103   //   * Deserializes PullCall. 
    104   //   * If skipObject is true - the call's object (when returning) is not deserialized. 
    105   //   * In this case, the caller should skip the stream to the next mark. 
    106   //   * 
    107   //   * \param is Input Stream 
    108   //   * \param skipObject Skip Object? (see above) 
    109   //   */ 
    110   //  public void possiblyIncompleteDeserialize(@Ref CoreInput is, boolean skipObject) { 
    111   //      super.deserialize(is); 
    112   //      intermediateAssign = is.readBoolean(); 
    113   //      ccPull = is.readBoolean(); 
    114   //      if (!skipObject && isReturning(true)) { 
    115   //          if (ccPull) { 
    116   //              data = (CCInterThreadContainer<?>)is.readObjectInInterThreadContainer(); 
    117   //          } else { 
    118   //              PortData tmp = (PortData)is.readObject(); 
    119   //              if (tmp != null) { 
    120   //                  info.curRef = tmp.getCurReference(); 
    121   //                  //info.lockEstimate = 5; // just take 5... performance is not critical here 
    122   //                  //info.setLocks = 1; // one for this call 
    123   //                  info.curRefCounter = info.curRef.getRefCounter(); 
    124   //                  info.curRefCounter.setLocks((byte)5); 
    125   //              } else { 
    126   //                  info.curRef = null; 
    127   //                  //info.lockEstimate = 5; // just take 5... performance is not critical here 
    128   //                  //info.setLocks = 1; // one for this call 
    129   //                  info.curRefCounter = null; 
    130   //              } 
    131   //          } 
    132   //      } 
    133   //  } 
    134  
    135   /* (non-Javadoc) 
    136    * @see core.port7.rpc.AbstractCall#deserialize(core.buffers.CoreInput) 
    137    */ 
    13875  virtual void Deserialize(tCoreInput& is); 
    13976 
     
    15087  } 
    15188 
    152   /* (non-Javadoc) 
    153    * @see core.port7.rpc.AbstractCall#serialize(core.buffers.CoreBuffer) 
    154    */ 
    15589  virtual void Serialize(tCoreOutput& oos) const; 
    156  
    157   //  @Override 
    158   //  public void genericRecycle() { 
    159   //      if (isResponsible()) { 
    160   //          //System.out.println("Recycling pull call: " + toString()); 
    161   //          if (ccPull) { 
    162   //              if (data != null) { 
    163   //                  data.recycle2(); 
    164   //              } 
    165   //          } else if (info.curRef != null) { 
    166   //              info.setLocks--; // release pull call's lock 
    167   //              info.releaseObsoleteLocks(); 
    168   //          } 
    169   //          reset(); 
    170   //          super.recycle(); 
    171   //      } 
    172   //  } 
    173  
    174   //  /** 
    175   //   * Initializes thread local cache in order to perform assignments in current runtime environment 
    176   //   * 
    177   //   * New buffer in thread local cache won't be locked - since only current thread may recycle it 
    178   //   */ 
    179   //  @InCppFile 
    180   //  public void setupThreadLocalCache() { 
    181   //      if (tc == null) { 
    182   //          tc = ThreadLocalCache.getFast(); 
    183   //          tc.data = tc.getUnusedBuffer(data.getType()); 
    184   //          tc.data.setRefCounter(0); 
    185   //          tc.data.assign(data.getDataPtr()); 
    186   //          tc.ref = tc.data.getCurrentRef(); 
    187   //      } else { 
    188   //          assert(ThreadLocalCache.getFast() == tc) : "Programming error"; 
    189   //      } 
    190   //  } 
    19190 
    19291  virtual const util::tString ToString() const 
  • port/rpc/tSynchMethodCallLogic.cpp

    r26 r57  
    3333{ 
    3434  // return value 
    35   //      ThreadLocalCache tc = ThreadLocalCache.getFast(); 
    36   //      if (tc.getThreadUid() == call.getThreadUid()) { // same thread - uncritical 
    37   //          @Ptr MethodCallSyncher mcs = tc.getMethodSyncher(); 
    38   //          if (mcs.beforeQuickReturnCheck) { // quick return 
    39   //              mcs.methodReturn = call; 
    40   //              return; 
    41   //          } 
    42   //          throw new RuntimeException("This shouldn't happen... thread waiting and returning at the same time... fishy"); 
    43   //      } 
    44  
    4535  tMethodCallSyncher* mcs = tMethodCallSyncher::Get(call->GetSyncherID()); 
    4636  mcs->ReturnValue(call); 
  • port/rpc/tSynchMethodCallLogic.h

    r27 r57  
    9696  } 
    9797 
    98 //  /** 
    99 //   * Mark this call and signal that it won't 
    100 //   * 
    101 //   * \param call Call 
    102 //   */ 
    103 //  public static void noQuickReturn(AbstractCall call) { 
    104 // 
    105 //  } 
    106  
    10798}; 
    10899 
  • port/std/tPortBase.cpp

    r28 r57  
    2222#include "core/portdatabase/tDataType.h" 
    2323#include "core/port/std/tPortBase.h" 
    24 #include "core/port/std/tPortDataBufferPool.h" 
    2524#include "core/port/std/tPullRequestHandler.h" 
    2625 
     
    4544  assert((pci.data_type->IsStdType())); 
    4645  InitLists(&(edges_src), &(edges_dest)); 
    47   //pDefaultValue = pdm.getData(); 
    48   //PortDataCreationInfo.get().reset(); 
    49   //pdm.setLocks(2); // one... so it will stay read locked... and another one for pValue 
    5046  value.Set(default_value->GetCurReference()); 
    5147  if (queue != NULL) 
     
    128124  (static_cast<tPortBase*>(other))->Publish(GetAutoLockedRaw()); 
    129125  ReleaseAutoLocks(); 
    130 } 
    131  
    132 tPortData* tPortBase::GetUnusedBufferRaw() 
    133 { 
    134   return buffer_pool == NULL ? multi_buffer_pool->GetUnusedBuffer(cur_data_type) : buffer_pool->GetUnusedBuffer(); 
    135  
    136   //      @Ptr ThreadLocalCache tli = ThreadLocalCache.get(); 
    137   //      @Ptr PortDataBufferPool pdbp = tli.getBufferPool(handle); 
    138   //      boolean hasSQ = hasSpecialReuseQueue(); 
    139   //      if ((!hasSQ) && pdbp != null) {  // common case 
    140   //          return pdbp.getUnusedBuffer(); 
    141   //      } 
    142   // 
    143   //      return getUnusedBuffer2(pdbp, tli, hasSQ); 
    144126} 
    145127 
     
    231213 
    232214  // lock value and return 
    233   //pc.curRef.getManager().addLock(); we already have extra lock from pullValueRawImpl 
    234   //pc.setLocks++; we already have extra lock from pullValueRawImpl 
    235215  pc.ReleaseObsoleteLocks(); 
    236216  return pc.cur_ref->GetData(); 
     
    279259    pc.set_locks++;  // lock for return 
    280260  } 
    281  
    282   //      PullCall pc = ThreadLocalCache.getFast().getUnusedPullCall(); 
    283   // 
    284   //      pc.ccPull = false; 
    285   //      pc.info.lockEstimate = intermediateAssign ? 2 : 1; // 3: 1 for call, 1 for this port, 1 for return 
    286   //      pc.info.setLocks = 0; 
    287   //      pc.intermediateAssign = intermediateAssign; 
    288   //      //pullValueRaw(pc); 
    289   //      try { 
    290   //          addLock(pc.info); // lock for the pull call 
    291   //          pc = SynchMethodCallLogic.<PullCall>performSynchCall(pc, this, callIndex, PULL_TIMEOUT); 
    292   //          addLock(pc.info); // lock for the outside 
    293   // 
    294   //          // assign if this wasn't done yet 
    295   //          if (!intermediateAssign) { 
    296   //              assign(pc.info); 
    297   //          } 
    298   // 
    299   //          assert(pc.info.curRef.isLocked()); 
    300   //          PortData result = pc.info.curRef.getData(); 
    301   //          pc.genericRecycle(); 
    302   //          assert(result.getCurReference().isLocked()); 
    303   // 
    304   //          return result; 
    305   //      } catch (MethodCallException e) { 
    306   // 
    307   //          // possibly timeout 
    308   //          pc.genericRecycle(); 
    309   //          return lockCurrentValueForRead(); 
    310   //      } 
    311261} 
    312262 
  • port/std/tPortBase.h

    r28 r57  
    3636#include "core/tFrameworkElement.h" 
    3737#include "core/port/tMultiTypePortDataBufferPool.h" 
     38#include "core/port/std/tPortDataBufferPool.h" 
    3839#include "core/port/tPortFlags.h" 
    3940#include "core/port/std/tPortDataImpl.h" 
     
    4647{ 
    4748class tDataType; 
    48 class tPortDataBufferPool; 
    4949class tPullRequestHandler; 
    5050 
     
    128128  static tPortData* CreateDefaultValue(tDataType* dt); 
    129129 
    130   //      @Ptr PortDataManager pdm = data.getManager(); 
    131   //      @Ptr ThreadLocalCache tli = ThreadLocalCache.get(); 
    132   // 
    133   //      @InCpp("size_t lockInfo = pdm->reuseCounter;") 
    134   //      @SizeT int lockInfo = 0; 
    135   //      @SizeT int dataRaw = 0; 
    136   // 
    137   //      boolean isLocked = pdm.isLocked(); 
    138   //      if ((!isLocked) && ThreadUtil.getCurrentThreadId() == pdm.getOwnerThread()) { // owns ports - common case 
    139   // 
    140   //          if (std11CaseReceiver != null) { // common, simple and most optimized case 
    141   //              @Ptr PortBase dest = std11CaseReceiver; 
    142   //              pdm.setLocksAsOwner(2); 
    143   // 
    144   //              // assign to this port 
    145   //              tli.newLastWrittenToPortByOwner(handle, data); 
    146   //              dataRaw = setValueInternal(data, lockInfo); 
    147   // 
    148   //              // assign to destination port 
    149   //              tli.newLastWrittenToPortByOwner(dest.getHandle(), data); 
    150   // 
    151   //              // JavaOnlyBlock 
    152   //              dest.value = data; 
    153   // 
    154   //               dest->value = data_raw; 
    155   // 
    156   //              dest.setChanged(); 
    157   //              return; 
    158   //          } 
    159   // 
    160   //          pdm.setLocksAsOwner(1); // lock from owner thread - no atomic operations needed for increasing reference counter 
    161   //          pdm.ownerRefCounter = 1; 
    162   // 
    163   //          // assign data 
    164   //          if (standardAssign) { 
    165   //              tli.newLastWrittenToPortByOwner(handle, data); 
    166   //              dataRaw = setValueInternal(data, lockInfo); 
    167   //          } else { 
    168   //              nonStandardAssign(data, tli); 
    169   //          } 
    170   // 
    171   //          // send data 
    172   //          @Ptr ArrayWrapper<PortBase> dests = edgesSrc.getIterable(); 
    173   //          for (@SizeT int i = 0, n = dests.size(); i < n; i++) { 
    174   //              @Ptr PortBase pb = dests.get(i); 
    175   //              if (pb != null && pb.getFlag(PortFlags.PUSH_STRATEGY)) { 
    176   //                  pb.receiveAsOwner(data, dataRaw, this, tli); 
    177   //              } 
    178   //          } 
    179   //      } else { 
    180   // 
    181   //          // initial lock 
    182   //          if (isLocked) { 
    183   //              pdm.addReadLock(); 
    184   //          } else { 
    185   //              pdm.setLocks(1); 
    186   //          } 
    187   // 
    188   //          // assign data 
    189   //          if (standardAssign) { 
    190   //              tli.newLastWrittenToPort(handle, data); 
    191   //              dataRaw = setValueInternal(data, lockInfo); 
    192   //          } else { 
    193   //              nonStandardAssign(data, tli); 
    194   //          } 
    195   // 
    196   //          // send data 
    197   //          @Ptr ArrayWrapper<PortBase> dests = edgesSrc.getIterable(); 
    198   //          for (@SizeT int i = 0, n = dests.size(); i < n; i++) { 
    199   //              @Ptr PortBase pb = dests.get(i); 
    200   //              if (pb != null && pb.getFlag(PortFlags.PUSH_STRATEGY)) { 
    201   //                  pb.receive(data, dataRaw, this, tli); 
    202   //              } 
    203   //          } 
    204   //      } 
    205   //  } 
    206  
    207   //  protected void receiveAsOwner(@Ptr PortDataImpl data, @SizeT int dataRaw, @Ptr PortBase origin, @Ptr ThreadLocalCache tli) { 
    208   //      if (standardAssign) { 
    209   //          data.getManager().addOwnerLock(); 
    210   //          tli.newLastWrittenToPortByOwner(handle, data); 
    211   // 
    212   //          // JavaOnlyBlock 
    213   //          value = data; 
    214   // 
    215   //           value = data_raw; 
    216   // 
    217   //          changed = true; 
    218   //          notifyListeners(); 
    219   //      } else { 
    220   //          nonStandardAssign(data, tli); 
    221   //      } 
    222   // 
    223   //      @Ptr ArrayWrapper<PortBase> dests = edgesSrc.getIterable(); 
    224   //      for (int i = 0, n = dests.size(); i < n; i++) { 
    225   //          @Ptr PortBase pb = dests.get(i); 
    226   //          if (pb != null && (pb.flags | PortFlags.PUSH_STRATEGY) > 0) { 
    227   //              pb.receiveAsOwner(data, dataRaw, this, tli); 
    228   //          } 
    229   //      } 
    230   // 
    231   //      dests = edgesDest.getIterable(); 
    232   //      for (int i = 0, n = dests.size(); i < n; i++) { 
    233   //          PortBase pb = dests.get(i); 
    234   //          if (pb != null && pb != origin && (pb.flags | PortFlags.PUSH_STRATEGY_REVERSE) > 0) { 
    235   //              pb.receiveReverse(data, dataRaw, tli); 
    236   //          } 
    237   //      } 
    238   //  } 
    239   // 
    240   //  private void receiveReverse(@Ptr PortDataImpl data, @SizeT int dataRaw, @Ptr ThreadLocalCache tli) { 
    241   //      if (standardAssign) { 
    242   //          data.getManager().addReadLock(); 
    243   //          tli.setLastWrittenToPort(handle, data); 
    244   // 
    245   //          // JavaOnlyBlock 
    246   //          value = data; 
    247   // 
    248   //           value = data_raw; 
    249   // 
    250   //          changed = true; 
    251   //          notifyListeners(); 
    252   //      } else { 
    253   //          nonStandardAssign(data, tli); 
    254   //      } 
    255   //  } 
    256  
    257130  inline void NotifyListeners(tPublishCache* pc) 
    258131  { 
     
    327200  const void PullValueRawImpl(tPublishCache& pc, bool intermediate_assign, bool first); 
    328201 
    329   //  @Inline protected void receiveReverse(@Ref PublishCache pc, PortBase origin) { 
    330   //      assign(pc); 
    331   //      setChanged(); 
    332   //      notifyListeners(pc); 
    333   //      updateStatistics(pc, this, origin); 
    334   //  } 
    335  
    336202  /*! 
    337203   * Update statistics if this is enabled 
     
    350216 
    351217  void AddLock(tPublishCache& pc); 
    352  
    353   /*protected void getReceivers(ArrayWrapper<PortBase> buffer, PortBase origin) { 
    354       buffer.add(this); 
    355  
    356       ArrayWrapper<PortBase> dests = edgesSrc.getIterable(); 
    357       for (int i = 0, n = dests.size(); i < n; i++) { 
    358           PortBase pb = dests.get(i); 
    359           if (pb != null && (pb.flags | PortFlags.PUSH_STRATEGY) > 0) { 
    360               pb.getReceivers(buffer, this); 
    361           } 
    362       } 
    363  
    364       dests = edgesDest.getIterable(); 
    365       for (int i = 0, n = dests.size(); i < n; i++) { 
    366           PortBase pb = dests.get(i); 
    367           if (pb != null && pb != origin && (pb.flags | PortFlags.PUSH_STRATEGY_REVERSE) > 0) { 
    368               pb.getReceiversReverse(buffer); 
    369           } 
    370       } 
    371   } 
    372  
    373   protected void getReceiversReverse(ArrayWrapper<PortBase> buffer) { 
    374       buffer.add(this); 
    375  
    376       ArrayWrapper<PortBase> dests = edgesDest.getIterable(); 
    377       for (int i = 0, n = dests.size(); i < n; i++) { 
    378           PortBase pb = dests.get(i); 
    379           if (pb != null && (pb.flags | PortFlags.PUSH_STRATEGY_REVERSE) > 0) { 
    380               pb.getReceiversReverse(buffer); 
    381           } 
    382       } 
    383   }*/ 
    384218 
    385219  /*! 
     
    422256  virtual void InitialPushTo(tAbstractPort* target, bool reverse); 
    423257 
    424   //  protected @Ptr PortDataImpl getUnusedBuffer2(@Managed PortDataBufferPool pdbp, ThreadLocalCache tli, boolean hasSQ) { 
    425   //      if (pdbp == null) { 
    426   //          pdbp = hasSQ ? new MultiTypePortDataBufferPool() : new PortDataBufferPool(dataType, 2); 
    427   //          tli.setBufferPool(handle, pdbp); 
    428   //      } 
    429   // 
    430   //      return hasSQ ? ((MultiTypePortDataBufferPool)pdbp).getUnusedBuffer(curDataType) : pdbp.getUnusedBuffer(); 
    431   //  } 
    432  
    433   // 
    434   //   * protected: PortDataContainerBase lockCurrentValueForRead() { 
    435   //   *     for(;;) { 
    436   //   *         PortData* curValue = value; 
    437   //   *         int iteration = (curValue & 0xF); 
    438   //   *         int counterIndex = iteration & 0x3; 
    439   //   *         int old = curValue->getManager()->refCounter.getAndAdd(PortDataContainerBase.refCounterIncrement[counterIndex]); 
    440   //   *         if ((old & PortDataManager::refCounterMasks[counterIndex]) != 0 && (iteration == (old >> 28))) { 
    441   //   *             assert counterIndex != PortDataManager::refCounterMasks[counterIndex]; 
    442   //   *             return value; 
    443   //   *         } 
    444   //   *     } 
    445   //   * } 
    446   // 
    447  
    448258  inline const tPortData* LockCurrentValueForRead() const 
    449259  { 
     
    463273    { 
    464274      tPortDataReference* cur_value = value.Get(); 
    465       //PortDataManager mgr = curValue.getManager(); 
    466       //boolean isOwner = ThreadUtil.getCurrentThreadId() == mgr.getOwnerThread(); 
    467  
    468       // short cut, if locked by owner thread 
    469       /*if (isOwner && mgr.ownerRefCounter > 0) { 
    470           mgr.ownerRefCounter++; 
    471           return curValue; 
    472       }*/ 
    473275 
    474276      if (cur_value->GetRefCounter()->TryLocks(add_locks)) 
     
    692494  } 
    693495 
    694   //  @Override 
    695   //  public TypedObject universalGetAutoLocked() { 
    696   //      return getAutoLocked(); 
    697   //  } 
    698  
    699496  /*! 
    700497   * Pulls port data (regardless of strategy) 
     
    719516   * (Using this method, typically no new buffers/objects need to be allocated) 
    720517   */ 
    721   tPortData* GetUnusedBufferRaw(); 
     518  inline tPortData* GetUnusedBufferRaw() 
     519  { 
     520    return buffer_pool == NULL ? multi_buffer_pool->GetUnusedBuffer(cur_data_type) : buffer_pool->GetUnusedBuffer(); 
     521  } 
    722522 
    723523  virtual void NotifyDisconnect(); 
     
    743543  } 
    744544 
    745   //  @Override 
    746   //  public void invokeCall(PullCall call) { 
    747   //      if (pullValueRaw(call)) { 
    748   //          SynchMethodCallLogic.handleMethodReturn(call); 
    749   //      } 
    750   //  } 
    751   // 
    752   //  /** 
    753   //   * Pull/read current value from source port 
    754   //   * When multiple source ports are available an arbitrary one of them is used. 
    755   //   * (Should only be called by framework-internal classes) 
    756   //   * 
    757   //   * \param pc Various parameters 
    758   //   * \return already returning pulled value (in same thread) 
    759   //   */ 
    760   //  @Virtual public boolean pullValueRaw(PullCall call) { 
    761   //      @Ptr PublishCache pc = call.info; 
    762   //      @Ptr ArrayWrapper<PortBase> sources = edgesDest.getIterable(); 
    763   //      if (pullRequestHandler != null) { 
    764   //          PortDataReference pdr = pullRequestHandler.pullRequest(this, (byte)++pc.lockEstimate).getCurReference(); 
    765   //          pc.curRef = pdr; 
    766   //          pc.curRefCounter = pdr.getRefCounter(); 
    767   //          call.setStatusReturn(); 
    768   //          assert(pdr.getRefCounter().get() >= pc.lockEstimate); 
    769   //          if (pc.curRef != value.get()) { 
    770   //              assign(pc); 
    771   //          } 
    772   //      } else { 
    773   //          // continue with next-best connected source port 
    774   //          for (@SizeT int i = 0, n = sources.size(); i < n; i++) { 
    775   //              PortBase pb = sources.get(i); 
    776   //              if (pb != null) { 
    777   //                  if (call.intermediateAssign) { 
    778   //                      pc.lockEstimate++; 
    779   //                  } 
    780   //                  call.pushCaller(this); 
    781   //                  boolean returning = pb.pullValueRaw(call); 
    782   //                  if (returning) { 
    783   //                      @CppUnused 
    784   //                      int x = call.popCaller(); // we're already returning, so we can remove ourselves from caller stack again 
    785   //                      assert(x == getHandle()); 
    786   //                      if (pc.curRef != value.get()) { // exploit thread for the calls he made anyway 
    787   //                          if (call.intermediateAssign) { 
    788   //                              assign(pc); 
    789   //                          } 
    790   //                      } 
    791   //                  } 
    792   //                  if (call.getStatus() != AbstractCall.CONNECTION_EXCEPTION) { 
    793   //                      return returning; 
    794   //                  } 
    795   //              } 
    796   //          } 
    797   // 
    798   //          // no connected source port... pull current value 
    799   //          pc.curRef = lockCurrentValueForRead((byte)pc.lockEstimate); 
    800   //          pc.curRefCounter = pc.curRef.getRefCounter(); 
    801   //          call.setStatusReturn(); 
    802   //      } 
    803   //      return true; 
    804   //  } 
    805   // 
    806   //  @Override 
    807   //  public void handleCallReturn(AbstractCall call) { 
    808   //      assert(call.isReturning(true)); 
    809   // 
    810   //      PullCall pc = (PullCall)call; 
    811   //      if (pc.info.curRef != value.get()) { 
    812   //          if (((PullCall)call).intermediateAssign) { 
    813   //              assign(pc.info); 
    814   //          } 
    815   //      } 
    816   // 
    817   //      // continue assignments 
    818   //      if (pc.callerStackSize() > 0) { 
    819   //          pc.returnToCaller(); 
    820   //      } else { 
    821   //          SynchMethodCallLogic.handleMethodReturn(pc); 
    822   //      } 
    823   //  } 
    824  
    825545  /*! 
    826546   * \param pull_request_handler Object that handles pull requests - null if there is none (typical case) 
  • port/std/tPortDataBufferPool.h

    r27 r57  
    105105  } 
    106106 
    107   //  @Override 
    108   //  public void enqueue(@Ptr PortDataManager pd) { 
    109   //      //assert !pd.isLocked(); 
    110   //      super.enqueue(pd); 
    111   //  } 
    112  
    113107  /*! 
    114108   * Prints info about all elements in pool to console 
  • port/std/tPortDataImpl.cpp

    r26 r57  
    3232{ 
    3333  tPortDataCreationInfo::Get()->AddUnitializedObject(this); 
    34   //owner = PortDataCreationInfo.get().getOwner(); 
    35   //type = PortDataCreationInfo.get().getType(); 
    3634  assert((((unsigned int)this) & 0x7) == 0); // make sure requested alignment was honoured 
    3735} 
     
    4442  } 
    4543  type = LookupDataType(); 
    46   //      if (type == null) { 
    47   //          int i = 4; 
    48   //      } 
    49   //      System.out.println(type); 
    5044  assert((type != NULL) && "Unknown Object type"); 
    5145} 
  • port/std/tPortDataImpl.h

    r27 r57  
    5656public: 
    5757 
    58   /*! Port to whose PortDataContainerPool this buffer belongs - automatically counts as initial user */ 
    59   //protected final Port<?> origin; 
    60  
    61   /*! Last iteration of PortTracker when he found this buffer assigned to a port */ 
    62   //protected volatile int lastTracked = -5; 
    63   //public static final int FILLING = Integer.MAX_VALUE; 
    64  
    65   /*! Value to add for user lock */ 
    66   //private final static int USER_LOCK = 0x10000; 
    67  
    68   /*! Constant to AND refCounter with to determine whether there's a user lock */ 
    69   //private final static int USER_LOCK_MASK = 0xFFFF0000; 
    70  
    71   /*! Constant to AND refCounter with to determine whether there's a system lock */ 
    72   //private final static int SYSTEM_LOCK_MASK = 0xFFFF; 
    73  
    7458  /*! Log domain for serialization */ 
    7559  RRLIB_LOG_CREATE_NAMED_DOMAIN(log_domain, "serialization"); 
     
    9983  } 
    10084 
    101   /* (non-Javadoc) 
    102    * @see core.port7.std.PortData#handleRecycle() 
    103    */ 
    10485  virtual void HandleRecycle() 
    10586  { 
    10687    // default: do nothing 
    10788  } 
    108  
    109   //  /** 
    110   //   * Add read lock to buffer. 
    111   //   * Prerequisite: Buffer needs to be already read-locked... 
    112   //   * (usually the case after getting buffer from port) 
    113   //   */ 
    114   //  // no extreme optimization necessary, since not called that often... 
    115   //  public void addReadLock() { 
    116   //      //int counterIndex = (refCounter.get() >> 28) & 0x3; 
    117   //      int counterIndex = reuseCounter & 0x3; 
    118   //      int old = refCounter.getAndAdd(refCounterIncrement[counterIndex]); 
    119   //      assert ((old & refCounterMasks[counterIndex]) != 0) : "Element already reused. Application in undefined state. Element has to be locked prior to calling this method."; 
    120   //      assert (counterIndex == ((old >> 28) & 0x3)) : "Counter index changed. Application in undefined state. Element has to be locked prior to calling this method."; 
    121   //      assert (counterIndex != refCounterMasks[counterIndex]) : "Reference counter overflow. Maximum of 127 locks allowed. Consider making a copy somewhere."; 
    122   //  } 
    123   // 
    124   //  /** 
    125   //   * Release lock from buffer 
    126   //   */ 
    127   //  public void releaseLock() { 
    128   //      int counterIndex = reuseCounter & 0x3; 
    129   //      int count = refCounter.addAndGet(-refCounterIncrement[counterIndex]); 
    130   //      assert ((count & refCounterMasks[counterIndex]) != refCounterMasks[counterIndex]) : "More locks released than acquired. Application in undefined state."; 
    131   //      if ((count & refCounterMasks[counterIndex]) == 0) { 
    132   //          // reuse object 
    133   //          PortDataBufferPool owner = this.owner; 
    134   //          reuseCounter++; 
    135   //          if (owner != null) { 
    136   //              owner.enqueue(this); 
    137   //          } else { 
    138   //               delete this; 
    139   //          } 
    140   //      } 
    141   //  } 
    14289 
    14390  /*! 
     
    14794  void InitDataType(); 
    14895 
    149   /*! 
    150    * For Port.get(). 
    151    * 
    152    * A user lock is added to object, if there's still a system lock. 
    153    * Otherwise it is outdated and the next one in port should be used. 
    154    * User locks may still appear to be there although object has been reused, 
    155    * if this method is called concurrently. 
    156    * 
    157    * \return Did lock succeed? 
    158    */ 
    159   /*boolean addUserLockIfSystemLock() { 
    160       int old = refCounter.getAndAdd(USER_LOCK); 
    161       if ((old & SYSTEM_LOCK_MASK) <= 0) { 
    162           refCounter.getAndAdd(-USER_LOCK); // remove interference 
    163           return false; 
    164       } 
    165       return true; 
    166   }*/ 
    167  
    168   /*! 
    169    * Add read lock to buffer (thread safe) 
    170    * 
    171    * \return Did lock succeed (or is element already reused) ? 
    172    */ 
    173   /*void addSystemReadLock() { 
    174       int old = refCounter.getAndIncrement(); 
    175       if (old <= 0) { 
    176           throw new RuntimeException("Element already reused"); 
    177       } 
    178   }*/ 
    179  
    180   /*! 
    181    * Release read lock (thread safe) 
    182    */ 
     96  // override toString to have it available in C++ for PortData 
    18397  virtual const util::tString ToString() const 
    18498  { 
  • port/std/tPortDataManager.cpp

    r27 r57  
    6060  //System.out.println("New port data manager"); 
    6161 
    62   //ownerThread = ThreadUtil.getCurrentThreadId(); 
    63  
    64   //PortDataCreationInfo.get().setType(type) - wäre obsolet, wenn man Typ irgendwie anders bekommen könnte 
    65  
    6662  tPortDataCreationInfo* pdci = tPortDataCreationInfo::Get(); 
    6763  pdci->SetManager(this); 
  • port/std/tPortDataManager.h

    r27 r57  
    237237protected: 
    238238 
    239   //  /** 
    240   //   * Reference/Lock counter - it is divided in four to avoid collisions with multiple iterations: 
    241   //   * [7bit counter[0]][7bit counter[1]][7bit counter[2]][7bit counter[3]][4 bit reuse counter] 
    242   //   * The reuse counter is incremented (and wrapped around) every time the buffer is recycled. 
    243   //   * Reuse counter % 4 is the index of the counter used (fast operation & 0x03) 
    244   //   * Warnings should be thrown if the reuse counter increases by two or more during a lock operation. 
    245   //   * If it increases by four or more, the counters may become corrupted. The program should be aborted. 
    246   //   * Increasing the initial number of buffers in the publish pool should solve the problem. 
    247   //   * 
    248   //   * There is a maximum of 127 locks per object (7 bit). 
    249   //   **/ 
    250   //  protected final AtomicInt refCounter = new AtomicInt(); // 4byte => 16byte 
    251  
    252   //  /** 
    253   //   * for optimizations: Thread that owns this buffer... could be moved to owner in order to save memory... however, owner would need to final => not null 
    254   //   */ 
    255   //  private final long ownerThread; 
    256  
    257   //  /** for optimizations: Reference/Lock counter for owner thread - when zero, the refCounter is decremented */ 
    258   //  int ownerRefCounter = 0; 
    259  
    260239  /*! incremented every time buffer is reused */ 
    261240  volatile int reuse_counter; 
     
    263242public: 
    264243 
    265   // static helper variables 
    266  
    267   /*! Bit masks for different counters in refCounter */ 
    268   //protected final static int[] refCounterMasks = new int[]{0xFE000000, 0x1FC0000, 0x3F800, 0x7F0}; 
    269  
    270   /*! Increment constant for different counters in refCounter */ 
    271   //protected final static int[] refCounterIncrement = new int[]{0x2000000, 0x40000, 0x800, 0x10}; 
    272  
    273   /*! Maximum number of locks */ 
    274   //public final static int MAX_LOCKS = 63;/*refCounterMasks[3] / 2; // due to sign*/ 
    275  
    276   /*! 
    277    * Masks for retrieving additional lock info from value pointer 
    278    */ 
    279   //public static final @SizeT int LOCK_INFO_MASK = 0x7; 
    280  
    281244  /*! Number of reference to port data (same as in PortDataImpl) */ 
    282245  static const size_t cNUMBER_OF_REFERENCES = 4u; 
     
    340303  } 
    341304 
    342   //  /** 
    343   //   * \return Thread that owns this buffer 
    344   //   */ 
    345   //  @Inline public long getOwnerThread() { 
    346   //      return ownerThread; 
    347   //  } 
    348  
    349   //  /** 
    350   //   * Release lock from buffer... may only be calld by owner thread 
    351   //   * 
    352   //   * (Should only be called by port directly) 
    353   //   */ 
    354   //  @Inline public void releaseOwnerLock() { 
    355   //      ownerRefCounter--; 
    356   //      //System.out.println("Release Lock: " + data + " " + ownerRefCounter); 
    357   //      if (ownerRefCounter == 0) { 
    358   //          releaseNonOwnerLock(); 
    359   //      } 
    360   //      assert ownerRefCounter >= 0 : "More locks released than acquired. Application in undefined state."; 
    361   //  } 
    362   // 
    363   //  /** 
    364   //   * Release lock from buffer 
    365   //   */ 
    366   //  @Inline public void releaseLock() { 
    367   //      if (ThreadUtil.getCurrentThreadId() == ownerThread) { 
    368   //          releaseOwnerLock(); 
    369   //      } else { 
    370   //          releaseNonOwnerLock(); 
    371   //      } 
    372   //  } 
    373   // 
    374   //  /** 
    375   //   * Release lock from buffer - atomic add operation 
    376   //   */ 
    377   //  @Inline private void releaseNonOwnerLock() { 
    378   //      int counterIndex = reuseCounter & 0x3; 
    379   //      int count = refCounter.addAndGet(-refCounterIncrement[counterIndex]); 
    380   //      assert ((count & refCounterMasks[counterIndex]) != refCounterMasks[counterIndex]) : "More locks released than acquired. Application in undefined state."; 
    381   //      if ((count & refCounterMasks[counterIndex]) == 0) { 
    382   //          // reuse object 
    383   //          //System.out.println("Recycling: " + data + " " + reuseCounter); 
    384   //          reuseCounter++; 
    385   //          recycle(); 
    386   //      } 
    387   //  } 
    388  
    389305  inline const tPortData* GetData() const 
    390306  { 
     
    439355  } 
    440356 
    441   //  /** 
    442   //   * (only called by port class) 
    443   //   * Set locks to specified amount 
    444   //   * 
    445   //   * \param count number of locks 
    446   //   */ 
    447   //  @Inline protected void setLocksAsOwner(int count) { 
    448   //      int counterIndex = reuseCounter & LOCK_INFO_MASK; 
    449   //      int counterIndex2 = counterIndex & 0x3; 
    450   //      refCounter.set((refCounterIncrement[counterIndex2]) | counterIndex); 
    451   //      ownerRefCounter = count; 
    452   //  } 
    453   // 
    454   //  // see above 
    455   //  @Inline protected void setLocksAsNonOwner(int count) { 
    456   //      int counterIndex = reuseCounter & LOCK_INFO_MASK; 
    457   //      int counterIndex2 = counterIndex & 0x3; 
    458   //      refCounter.set((refCounterIncrement[counterIndex2] * count) | counterIndex); 
    459   //  } 
    460  
    461   //  /** 
    462   //   * (only called by port classes) 
    463   //   * Set locks to specified amount 
    464   //   * 
    465   //   * \param count number of locks 
    466   //   */ 
    467   //  @Inline public void setLocks(int count) { 
    468   //      /*int counterIndex = reuseCounter & LOCK_INFO_MASK; 
    469   //      int counterIndex2 = counterIndex & 0x3;*/ 
    470   //      int counterIndex2 = reuseCounter & 0x3; 
    471   //      refCounter.set((refCounterIncrement[counterIndex2] * count) | counterIndex2); 
    472   //  } 
    473  
    474   //  // see above 
    475   //  @Inline protected @Ptr PortDataManager setLocks(int count) { 
    476   //      if (ThreadUtil.getCurrentThreadId() == ownerThread) { 
    477   //          setLocksAsOwner(count); 
    478   //      } else { 
    479   //          setLocksAsNonOwner(count); 
    480   //      } 
    481   //      return this; 
    482   //  } 
    483  
    484   //  /** 
    485   //   * \return Is Buffer currently locked? 
    486   //   */ 
    487   //  @Inline public boolean isLocked() { 
    488   //      int counterIndex = reuseCounter & 0x3; 
    489   //      int count = refCounter.get(); 
    490   //      return (count & refCounterMasks[counterIndex]) > 0; 
    491   //  } 
    492   // 
    493   //  /** 
    494   //   * Acquire read lock. 
    495   //   * Prerequisite: Buffer needs to be already read-locked... 
    496   //   * (usually the case after getting buffer from port) 
    497   //   */ 
    498   //  @Inline public void addReadLock() { 
    499   //      if (ThreadUtil.getCurrentThreadId() == ownerThread) { 
    500   //          if (ownerRefCounter > 0) { 
    501   //              ownerRefCounter++; 
    502   //              return; 
    503   //          } else { 
    504   //              ownerRefCounter = 1; 
    505   //          } 
    506   //      } 
    507   //      int counterIndex = reuseCounter & 0x3; 
    508   //      int old = refCounter.getAndAdd(refCounterIncrement[counterIndex]); 
    509   //      assert ((old & refCounterMasks[counterIndex]) != 0) : "Element already reused. Application in undefined state. Element has to be locked prior to calling this method."; 
    510   //      assert (counterIndex == ((old >> 28) & 0x3)) : "Counter index changed. Application in undefined state. Element has to be locked prior to calling this method."; 
    511   //      assert (counterIndex != refCounterMasks[counterIndex]) : "Reference counter overflow. Maximum of 127 locks allowed. Consider making a copy somewhere."; 
    512   //  } 
    513   // 
    514   //  /** 
    515   //   * Add owner lock. 
    516   //   * Precondition: there's already a owner lock 
    517   //   */ 
    518   //  void addOwnerLock() { 
    519   //      assert ownerRefCounter > 0 : "Element already reused. Application in undefined state. Element has to be locked prior to calling this method."; 
    520   //      ownerRefCounter++; 
    521   //  } 
    522  
    523   /*! 
    524    * Releases all lock from object 
    525    * (should only be called prior to deletion - by ports) 
    526    */ 
    527   /*void releaseAllLocks() { 
    528       assert refCounter.get() > 0 : "Element already recycled"; 
    529       refCounter.set(0); 
    530       ownerRefCounter = 0; 
    531  
    532       // reuse object 
    533       PortDataBufferPool owner = this.owner; 
    534       reuseCounter++; 
    535       if (owner != null) { 
    536           owner.enqueue(this); 
    537       } else { 
    538            delete this; 
    539       } 
    540   }*/ 
    541  
    542357  /*! 
    543358   * \param unused Is this (still) a unused buffer? 
  • port/std/tPortQueue.h

    r27 r57  
    8282  } 
    8383 
    84 //  /** 
    85 //   * How many chunks should be allocated in advance? (one is typically far more than enough). 
    86 //   * However, in special cases it might be necessary to preallocate more (if one thread may 
    87 //   * write masses of data to this port in a very short time - this will end in an null pointer exception). 
    88 //   */ 
    89 //  private final int preAllocate; 
    90 // 
    91 //  /** Fragments or chunks that are currently used */ 
    92 //  private final PortQueueFragment[] chunks; 
    93 // 
    94 //  /** Counts number of writes - element is found in chunks[writeIndex & chunkMask]->array[writeIndex & PQF.MASK]*/ 
    95 //  private final AtomicInteger writeIndex = new AtomicInteger(0); 
    96 // 
    97 //  /** Counts number of reads */ 
    98 //  private int readIndex; 
    99 // 
    100 //  /** Mask to and index with to get chunk (see below) */ 
    101 //  private final int chunkMask; 
    102 // 
    103 //  /** above, but unshifted */ 
    104 //  private final int rawChunkMask; 
    105 // 
    106 //  /** 
    107 //   * \param maxElements Maximum number of elements in queue. 
    108 //   * \param preAllocate How many chunks should be allocated in advance? (one is typically far more that enough). 
    109 //   * However, in special cases it might be necessary to preallocate more (if one thread may 
    110 //   * write masses of elements to this port at once - this will end in an null pointer exception). 
    111 //   */ 
    112 //  public PortQueue(int maxElements, int preAllocate) { 
    113 //      int chunkCount = (maxElements - 1 / PortQueueFragment.SIZE) + 1 + 3 + preAllocate; // (3 is for safety/reservation overhead) 
    114 //      int bits = 32 - Integer.numberOfLeadingZeros(chunkCount - 1); 
    115 //      chunkCount = 1 << bits; 
    116 //      chunks = new PortQueueFragment[chunkCount]; 
    117 //      this.preAllocate = Math.min(1, preAllocate); 
    118 // 
    119 //      // calculate mask 
    120 //      rawChunkMask = ((1 << bits) - 1); 
    121 //      chunkMask = rawChunkMask << PortQueueFragment.BITS; 
    122 // 
    123 //      // fill first <preallocate> chunks 
    124 //      for (int i = 0; i < preAllocate; i++) { 
    125 //          chunks[i] = ThreadLocalCache.get().getUnusedPortQueueFragment(); 
    126 //      } 
    127 //  } 
    128 // 
    129 //  /** 
    130 //   * Enqueue element in queue 
    131 //   * (Thread-safe) 
    132 //   * 
    133 //   * \param element Element to add 
    134 //   */ 
    135 //  public void enqueue(PortData element) { 
    136 // 
    137 // 
    138 // 
    139 //      int index = writeIndex.getAndIncrement(); // the only atomic operation necessary 
    140 //      int chunkIdx = index & chunkMask; 
    141 //      int elemIdx = index & PortQueueFragment.MASK; 
    142 //      if (elemIdx == 0) { // time for allocation? 
    143 //          int idx = (chunkIdx + preAllocate) & rawChunkMask; 
    144 //          assert(chunks[idx] == null); 
    145 //          chunks[idx] = ThreadLocalCache.get().getUnusedPortQueueFragment(); 
    146 //      } 
    147 //      assert(chunks[chunkIdx].array[elemIdx] == null); 
    148 //      chunks[chunkIdx].array[elemIdx] = element; 
    149 //  } 
    150 // 
    151 //  /** 
    152 //   * Dequeue element from queue. 
    153 //   * (May only be called by one thread concurrently.) 
    154 //   * 
    155 //   * \return Element returned element 
    156 //   */ 
    157 //  @SuppressWarnings("unchecked") 
    158 //  public T dequeue() { 
    159 //      int index = readIndex; 
    160 //      int chunkIdx = index & chunkMask; 
    161 //      int elemIdx = index & PortQueueFragment.MASK; 
    162 //      T result = (T)chunks[chunkIdx].array[elemIdx]; 
    163 //      if (result != null) { 
    164 //          chunks[chunkIdx].array[elemIdx] = null; 
    165 //          index++; 
    166 //          if (elemIdx == PortQueueFragment.MASK) { // recycle current chunk? 
    167 //              chunks[chunkIdx].recycle(); 
    168 //              chunks[chunkIdx] = null; 
    169 //          } 
    170 //      } 
    171 //      return result; 
    172 //  } 
    173  
    17484}; 
    17585 
  • port/std/tPortQueueElement.h

    r27 r57  
    4646  tPortQueueElement() {} 
    4747 
    48   //PortDataReference ref; 
    49  
    50   //  /** Number of bits for fragment index/size - currently 128 elements */ 
    51   //  public static final @SizeT int BITS = 7; 
    52   // 
    53   //  /** Size of one backend chunk - must be 2^n */ 
    54   //  public static final @SizeT int SIZE = 1 << BITS; 
    55   // 
    56   //  /** Mask to add absolute index with */ 
    57   //  public static final @SizeT int MASK = SIZE - 1; 
    58   // 
    59   //  /** Array backend for chunk */ 
    60   //  @InCpp("void* array[SIZE];") 
    61   //  Object[] array = new Object[SIZE]; 
    62   // 
    63   //  public PortQueueFragment() { 
    64   // 
    65   //      // initialize array 
    66   //      for (size_t i = 0; i < CHUNK_SIZE; i++) { 
    67   //          array[i] = NULL; 
    68   //      } 
    69   // 
    70   //  } 
    71   // 
    72   /*  @Override 
    73       public void recycle() { 
    74           super.recycle(); 
    75       }*/ 
    76  
    7748  void Recycle(bool recycle_content); 
    7849 
  • port/stream/tOutputStreamPort.h

    r27 r57  
    6161  } 
    6262 
    63   /* 
     63  /*! 
    6464   * Write data buffer instantly to connected ports. 
    6565   * (only valid to call this on buffers that do not commit data deferred) 
     
    7272  } 
    7373 
    74   /* (non-Javadoc) 
    75    * @see core.port4.Port#getUnusedBuffer() 
    76    */ 
    7774  inline T* GetUnusedBuffer() 
    7875  { 
  • port/stream/tOutputTransactionStreamPort.h

    r27 r57  
    102102  void CommitData(tCoreSerializable& data); 
    103103 
    104   /* (non-Javadoc) 
    105    * @see core.port4.Port#getUnusedBuffer() 
    106    */ 
    107104  tTransactionPacket* GetUnusedBuffer(); 
    108105 
  • port/stream/tSingletonPort.h

    r27 r57  
    7171  tSingletonPort(tPortCreationInfo pci, T* singleton); 
    7272 
    73 //  @Override 
    74 //  public PortDataContainer<T> browserGetData(Object locker) { 
    75 //      return singletonValue; 
    76 //  } 
    77 // 
    78 // 
    79 //  @Override 
    80 //  public void browserSet(PortDataContainer<T> newValue) { 
    81 //      if (newValue != singletonValue) { 
    82 //          throw new RuntimeException("Cannot change contents of Singleton-Port"); 
    83 //      } 
    84 //  } 
    85 // 
    86 //  @Override 
    87 //  protected PortDataContainer<T> getInternal() { 
    88 //      return singletonValue; 
    89 //  } 
    90  
    9173}; 
    9274 
  • port/stream/tStreamCommitThread.h

    r54 r57  
    7979  } 
    8080 
    81   //  public static void staticStop() { 
    82   //      if (instance == null) { 
    83   //          return; 
    84   //      } 
    85   //      instance.stopThread(); 
    86   //      try { 
    87   //          instance.join(); 
    88   //      } catch (InterruptedException e) { 
    89   //          //e.printStackTrace(); 
    90   //          System.out.println("Exception in StreamCommitThread::staticStop"); 
    91   //      } 
    92   //      instance = null; 
    93   //  } 
    94  
    9581  virtual void StopThread() 
    9682  { 
  • port/tAbstractPort.cpp

    r56 r57  
    6262    min_net_update_time(pci.min_net_update_interval) 
    6363{ 
    64   //      if (getFlag(PortFlags.IS_SHARED)) { 
    65   //          createDefaultLink(); 
    66   //      } 
    6764} 
    6865 
     
    114111    { 
    115112      RawConnectToTarget(target); 
    116       //              strategy = (short)Math.max(0, strategy); 
    117       //              target.strategy = (short)Math.max(0, target.strategy); 
    118113      target->PropagateStrategy(NULL, this); 
    119114      NewConnection(target); 
     
    453448  } 
    454449 
    455   // Check will be done by data type 
    456   /*if (getFlag(PortFlags.IS_CC_PORT) != target.getFlag(PortFlags.IS_CC_PORT)) { 
    457       return false; 
    458   } 
    459   if (getFlag(PortFlags.IS_INTERFACE_PORT) != target.getFlag(PortFlags.IS_INTERFACE_PORT)) { 
    460       return false; 
    461   }*/ 
    462  
    463450  if (!data_type->IsConvertibleTo(target->data_type)) 
    464451  { 
     
    471458{ 
    472459  util::tLock lock1(this); 
    473  
    474   //      // remove links 
    475   //      if (linksTo != null) { 
    476   //          for (@SizeT int i = 0; i < linksTo.size(); i++) { 
    477   //              getRuntime().removeLink(linksTo.get(i)); 
    478   //          } 
    479   //          linksTo.clear(); 
    480   //      } 
    481460 
    482461  // disconnect all edges 
    483462  DisconnectAll(); 
    484  
    485   // publish deletion - done by FrameworkElement class now 
    486   //publishUpdatedPortInfo(); 
    487463} 
    488464 
  • port/tAbstractPort.h

    r27 r57  
    8585  tEdgeList<>* edges_dest; 
    8686 
    87   //  /** Contains names of any links to this port - for efficient destruction */ 
    88   //  protected @Ptr SimpleList<String> linksTo; 
    89  
    9087  /*! Contains any link edges created by this port */ 
    9188  util::tSimpleList<tLinkEdge*>* link_edges; 
     
    107104  tDataType* const data_type; 
    108105 
    109   //  /** Counter for pull & method calls in this port */ 
    110   //  protected final AtomicInt callIndex = new AtomicInt(0); 
    111  
    112106  /*! Minimum network update interval. Value < 0 means default for this type */ 
    113107  int16 min_net_update_time; 
     
    133127   */ 
    134128  void ConsiderInitialReversePush(tAbstractPort* target); 
    135  
    136   //          if (!acceptsReverseData()) { 
    137   //              if (strategy > 0 && max <= 0) { // reset INITIAL_PUSH_RECEIVED flag, when we switch to a pull strategy (so that switch to push strategy will cause a push again) 
    138   //                  setFlag(PortFlags.INITIAL_PUSH_RECEIVED, false); 
    139   //              } else if (strategy <= 0 && max > 0) { // we should consider an initial push 
    140   //                  if ((!hasIncomingEdges()) && considerPush) { 
    141   //                      for (int i = 0, n = it.size(); i < n; i++) { 
    142   //                          @Ptr AbstractPort port = it.get(i); 
    143   //                          if (port != null && port.pushStrategy()) { 
    144   //                              considerInitialPush(port); 
    145   //                          } 
    146   //                      } 
    147   //                  } 
    148   //              } 
    149   //          } 
    150129 
    151130  /*! 
     
    269248  { 
    270249    changed = cCHANGED_INITIAL; 
    271     /*if (parent instanceof PortSet) { 
    272         ((PortSet)parent).childChanged(); 
    273     }*/ 
    274250  } 
    275251 
     
    283259  virtual void SetMaxQueueLengthImpl(int length) = 0; 
    284260 
    285   //  /** 
    286   //   * \return Has port (ever) been linked? 
    287   //   */ 
    288   //  @ConstMethod public boolean isLinked() { 
    289   //      return linksTo != null; 
    290   //  } 
    291   // 
    292   //  /** 
    293   //   * Does link name link to port? 
    294   //   * 
    295   //   * \param linkName link name 
    296   //   * \return Answer 
    297   //   */ 
    298   //  @ConstMethod public boolean isLinked(@Const @Ref String linkName) { 
    299   //      if (linksTo == null) { 
    300   //          return false; 
    301   //      } 
    302   //      for (@SizeT int i = 0; i < linksTo.size(); i++) { 
    303   //          if (linksTo.get(i).equals(linkName)) { 
    304   //              return true; 
    305   //          } 
    306   //      } 
    307   //      return false; 
    308   //  } 
    309  
    310261  /*! 
    311262   * Update edge statistics 
     
    316267   */ 
    317268  void UpdateEdgeStatistics(tAbstractPort* source, tAbstractPort* target, tTypedObject* data); 
    318  
    319   //  /** 
    320   //   * \return Does port "want" to receive an initial push? Typically it does, unless it has multiple sources or no push strategy itself. 
    321   //   * (Standard implementation for this) 
    322   //   */ 
    323   //  @SuppressWarnings("unchecked") 
    324   //  protected boolean wantsInitialPush() { 
    325   //      int sources = 0; 
    326   //      @Ptr ArrayWrapper<AbstractPort> src = edgesDest.getIterable(); 
    327   //      for (int i = 0, n = src.size(); i < n; i++) { 
    328   //          @Ptr AbstractPort pb = src.get(i); 
    329   //          if (pb != null && pb.isReady()) { 
    330   //              sources++; 
    331   //          } 
    332   //      } 
    333   //      return isReady() && strategy > 0 && sources <= 1; 
    334   //  } 
    335269 
    336270  template <bool cREVERSE, int8 cCHANGE_CONSTANT> 
     
    377311  tAbstractPort(tPortCreationInfo pci); 
    378312 
    379   //  /** 
    380   //   * Is specified link, the first link to this port? 
    381   //   * 
    382   //   * \param link link name 
    383   //   * \return Answer 
    384   //   */ 
    385   //  @ConstMethod public boolean isFirstLink(@Const @Ref String link) { 
    386   //      return linksTo.get(0).equals(link); 
    387   //  } 
    388  
    389   //  /** 
    390   //   * Return link name of link number i 
    391   //   * 
    392   //   * \param i 
    393   //   * \param buffer Buffer for result 
    394   //   * \return link name 
    395   //   */ 
    396   //  @ConstMethod public /*@Const @Ref*/ void getLink(int i, @Ref StringBuilder buffer) { 
    397   //      getQualifiedLink(buffer, i); 
    398   //  } 
    399  
    400313  /*! 
    401314   * \return Does port accept reverse data? 
     
    534447  } 
    535448 
    536   //  /** 
    537   //   * \return Current data auto-locked - Universal & virtual method - call ThreadLocalCache.get().releaseAllLocks to release lock 
    538   //   */ 
    539   //  @Virtual public abstract TypedObject universalGetAutoLocked(); 
    540  
    541449  /*! 
    542450   * \return Minimum Network Update Interval (only-port specific one; -1 if there's no specific setting for port) 
     
    595503  } 
    596504 
    597   //  /** 
    598   //   * \return Does port have edges to destinations with push strategy? 
    599   //   */ 
    600   //  @SuppressWarnings("unchecked") @ConstMethod 
    601   //  public boolean hasActiveEdges() { 
    602   //      @Ptr ArrayWrapper<AbstractPort> it = edgesSrc.getIterable(); 
    603   //      for (int i = 0, n = it.size(); i < n; i++) { 
    604   //          @Ptr AbstractPort port = it.get(i); 
    605   //          if (port.getFlag(PortFlags.PUSH_STRATEGY)) { 
    606   //              return true; 
    607   //          } 
    608   //      } 
    609   //      return false; 
    610   //  } 
    611  
    612   //  /** 
    613   //   * \return Does port have edges to sources with push strategy? 
    614   //   */ 
    615   //  @SuppressWarnings("unchecked") @ConstMethod 
    616   //  public boolean hasActiveEdgesReverse() { 
    617   //      @Ptr ArrayWrapper<AbstractPort> it = edgesDest.getIterable(); 
    618   //      for (int i = 0, n = it.size(); i < n; i++) { 
    619   //          @Ptr AbstractPort port = it.get(i); 
    620   //          if (port != null && port.getFlag(PortFlags.PUSH_STRATEGY_REVERSE)) { 
    621   //              return true; 
    622   //          } 
    623   //      } 
    624   //      return false; 
    625   //  } 
    626  
    627505  /*! 
    628506   * \return Does port have incoming edges? 
     
    765643  { 
    766644    changed = cCHANGED; 
    767     /*if (parent instanceof PortSet) { 
    768         ((PortSet)parent).childChanged(); 
    769     }*/ 
    770645  } 
    771646 
     
    778653  { 
    779654    changed = change_constant; 
    780     /*if (parent instanceof PortSet) { 
    781         ((PortSet)parent).childChanged(); 
    782     }*/ 
    783655  } 
    784656 
  • port/tPortFlags.h

    r27 r57  
    7474  static const int cNON_STANDARD_ASSIGN = cFIRST_PORT_FLAG << 8; 
    7575 
    76   /*! Does port contain "cheap-copy" data? */ 
    77   //public static final int IS_CC_PORT = FIRST_CUSTOM_FLAG << 10; 
    78  
    79   /*! Is this an interface port? */ 
    80   //public static final int IS_INTERFACE_PORT = FIRST_CUSTOM_FLAG << 11; 
    81  
    82   //  /** Should port have global link (the same in every Runtime - without origin server prefix) */ 
    83   //  public static final int GLOBAL_LINK = FIRST_PORT_FLAG << 9; 
    84  
    8576  /*! Transport data for this port through the network with high priority */ 
    8677  static const int cIS_EXPRESS_PORT = cFIRST_PORT_FLAG << 9; 
     
    9788  static const int cUSES_QUEUE = cFIRST_CUSTOM_NON_CONST_FLAG; 
    9889 
    99   //  /** Does port currently accept reverse incoming data? - changeable - requires MAY_ACCEPT_REVERSE_DATA */ 
    100   //  public static final int ACCEPTS_REVERSE_DATA = FIRST_CUSTOM_NON_CONST_FLAG << 1; 
    101  
    10290  /*! Restore default value, if port is disconnected? - changeable */ 
    10391  static const int cDEFAULT_ON_DISCONNECT = cFIRST_CUSTOM_NON_CONST_FLAG << 1; 
     
    10896  /*! Use push strategy rather than pull strategy in reverse direction? - changeable */ 
    10997  static const int cPUSH_STRATEGY_REVERSE = cFIRST_CUSTOM_NON_CONST_FLAG << 3; 
    110  
    111   //  /** Relevant when ports are connected - Has "initial push" been received? - changeable */ 
    112   //  public static final int INITIAL_PUSH_RECEIVED = FIRST_CUSTOM_NON_CONST_FLAG << 4; 
    11398 
    11499  ////////// Derived Flags //////// 
  • port/tThreadLocalCache.cpp

    r54 r57  
    131131      } 
    132132 
    133       //              // Delete pool 
    134       //              @Ptr PortDataBufferPool pool = tli.getBufferPool(handle); 
    135       //              if (pool != null) { 
    136       //                  pool.controlledDelete(); 
    137       //                  tli.setBufferPool(handle, null); 
    138       //              } 
    139133    } 
    140134  } 
     
    150144    method_syncher->Release(); 
    151145  } 
    152  
    153   ///** Get back any returned buffers */ 
    154   //reclaimReturnedBuffers(); 
    155146 
    156147  /*! Delete local port data buffer pools */ 
     
    180171    } 
    181172  } 
    182  
    183   //          // Release port data lock - NO!!! - may release last lock on used data... data will be deleted with pool (see below) 
    184   //          PortData pd = getLastWrittenToPortRaw(i); 
    185   //          if (pd != null) { 
    186   //              pd.getManager().releaseOwnerLock(); 
    187   //              setLastWrittenToPort(i, null); 
    188   //          } 
    189   // 
    190   //          // Delete pool 
    191   //          @Ptr PortDataBufferPool pool = getBufferPool(i); 
    192   //          if (pool != null) { 
    193   //              pool.controlledDelete(); 
    194   //              setBufferPool(i, null); 
    195   //          } 
    196   //      } 
    197173} 
    198174 
  • port/tThreadLocalCache.h

    r27 r57  
    6868private: 
    6969 
    70   //  @Struct 
    71   //  public class PortInfo { 
    72   // 
    73   //      /** Element that was last written to port by this thread */ 
    74   //      @Ptr PortData lastWrittenToPort; 
    75   // 
    76   //      /** thread-owned data buffer pool for writing to port */ 
    77   //      @Ptr PortDataBufferPool dataBufferPool; 
    78   //  } 
    79   // 
    80   //  /** Thread local port information - list index is last part of port handle */ 
    81   //  @InCpp("PortInfo portInfo[CoreRegister<>::MAX_ELEMENTS];") 
    82   //  public final PortInfo[] portInfo = new PortInfo[CoreRegister.MAX_ELEMENTS]; 
    83  
    8470  /*! Object to gain fast access to the thread local information */ 
    8571  static util::tFastStaticThreadLocal<tThreadLocalCache, tThreadLocalCache, util::tGarbageCollector::tFunctor> info; 
     
    9177  ::std::tr1::shared_ptr<util::tSimpleListWithMutex<tThreadLocalCache*> > infos_lock; 
    9278 
    93   //new SimpleList<WeakReference<ThreadLocalCache>>(); // = new SimpleList<WeakReference<ThreadLocalInfo>>(RuntimeSettings.MAX_THREADS.get()); 
    94  
    95   /*! Index of ThreadLocalCache - unique as long as thread exists */ 
    96   // dangerous! index changes, because infos is simple list 
    97   //private final @SizeT int index; 
    98  
    99   /*! Thread that info belongs to */ 
    100   //private final @SharedPtr Thread thread; 
    101  
    102   /*! List with locks... */ 
    103   //private final SimpleList<PortData> curLocks = new SimpleList<PortData>(); 
    104  
    10579  /*! object to help synchronize method calls - lazily initialized */ 
    10680  tMethodCallSyncher* method_syncher; 
     
    129103 
    130104  // at the beginning: diverse cached information 
    131  
    132   // pointers to current port information - portInfo1 is typically the publishing port */ 
    133   /*public @Ptr PortInfo portInfo1, portInfo2; 
    134  
    135   //int iteration; 
    136   //PortDataManager mgr; 
    137   int maskIndex; 
    138   int counterMask; 
    139   int counterIncrement;*/ 
    140105 
    141106  tCCPortDataContainer<>* data; 
     
    240205  } 
    241206 
    242   //  // internal methods for universal access in Java and C++ 
    243   //  @InCpp("return portInfo[index].lastWrittenToPort;") 
    244   //  @Inline @ConstMethod private PortData getLastWrittenToPortRaw(@SizeT int index) { 
    245   //      return lastWrittenToPort[index]; 
    246   //  } 
    247   // 
    248   //  @InCpp("portInfo[index].lastWrittenToPort = data;") 
    249   //  @Inline private void setLastWrittenToPortRaw(@SizeT int index, @Ptr PortData data) { 
    250   //      lastWrittenToPort[index] = data; 
    251   //  } 
    252   // 
    253   //  @InCpp("return portInfo[index].dataBufferPool;") 
    254   //  @Inline @ConstMethod private @Ptr PortDataBufferPool getPoolRaw(@SizeT int index) { 
    255   //      return dataBufferPools[index]; 
    256   //  } 
    257   // 
    258   //  @InCpp("portInfo[index].dataBufferPool = data;") 
    259   //  @Inline private void setPoolRaw(@SizeT int index, @Ptr PortDataBufferPool data) { 
    260   //      dataBufferPools[index] = data; 
    261   //  } 
    262   // 
    263   // 
    264   //  /** 
    265   //   * (Should only be called by port implementations) 
    266   //   * 
    267   //   * \param portHandle Handle of Port 
    268   //   * \return Data that was last written the port by this thread 
    269   //   */ 
    270   //  @Inline @ConstMethod public PortData getLastWrittenToPort(int portHandle) { 
    271   //      return getLastWrittenToPortRaw(portHandle & CoreRegister.ELEM_INDEX_MASK); 
    272   //  } 
    273   // 
    274   //  /** 
    275   //   * (Should only be called by port implementations) 
    276   //   * 
    277   //   * Set data that was last written to a port by this thread 
    278   //   * 
    279   //   * \param portHandle Handle of Port 
    280   //   * \param data Data 
    281   //   */ 
    282   //  @Inline public void setLastWrittenToPort(int portHandle, PortData data) { 
    283   //      setLastWrittenToPortRaw(portHandle & CoreRegister.ELEM_INDEX_MASK, data); 
    284   //  } 
    285   // 
    286   //  /** 
    287   //   * (Should only be called by port implementations) 
    288   //   * 
    289   //   * Thread needs to be the owner of this buffer 
    290   //   * 
    291   //   * Replace lastWrittenToPort value with new. 
    292   //   * Decrease reference counter of the old one. 
    293   //   * 
    294   //   * \param portHandle Handle of Port 
    295   //   * \param data Data 
    296   //   */ 
    297   //  @Inline public void newLastWrittenToPortByOwner(int portHandle, PortData data) { 
    298   //      assert (ThreadUtil.getCurrentThreadId() == data.getManager().getOwnerThread()) : "Thread is not owner"; 
    299   //      int index = portHandle & CoreRegister.ELEM_INDEX_MASK; 
    300   //      PortData old = getLastWrittenToPortRaw(index); 
    301   //      if (old != null) { 
    302   //          old.getManager().releaseOwnerLock(); 
    303   //      } 
    304   //      setLastWrittenToPort(index, data); 
    305   //  } 
    306   // 
    307   //  /** 
    308   //   * (Should only be called by port implementations) 
    309   //   * 
    310   //   * Thread needs to be the owner of this buffer 
    311   //   * 
    312   //   * Replace lastWrittenToPort value with new. 
    313   //   * Decrease reference counter of the old one. 
    314   //   * 
    315   //   * \param portHandle Handle of Port 
    316   //   * \param data Data 
    317   //   */ 
    318   //  @Inline public void newLastWrittenToPort(int portHandle, PortData data) { 
    319   //      int index = portHandle & CoreRegister.ELEM_INDEX_MASK; 
    320   //      PortData old = getLastWrittenToPortRaw(index); 
    321   //      if (old != null) { 
    322   //          old.getManager().releaseLock(); 
    323   //      } 
    324   //      setLastWrittenToPortRaw(index, data); 
    325   //  } 
    326   // 
    327   //  /** 
    328   //   * (Should only be called by port implementations) 
    329   //   * 
    330   //   * \param portHandle Handle of Port 
    331   //   * \return Buffer pool for port. May be null, if no data has been written to port yet. 
    332   //   */ 
    333   //  @Inline @ConstMethod @Ptr public PortDataBufferPool getBufferPool(int portHandle) { 
    334   //      return getPoolRaw(portHandle & CoreRegister.ELEM_INDEX_MASK); 
    335   //  } 
    336   // 
    337   //  /** 
    338   //   * (Should only be called by port implementations) 
    339   //   * 
    340   //   * \param PortHandle Handle of Port 
    341   //   * \param pool Buffer pool for port. 
    342   //   */ 
    343   //  @Inline public void setBufferPool(int portHandle, @Ptr PortDataBufferPool pool) { 
    344   //      setPoolRaw(portHandle & CoreRegister.ELEM_INDEX_MASK, pool); 
    345   //  } 
    346   // 
    347207  /*! 
    348208   * (Should only be called by port) 
     
    387247  } 
    388248 
    389   // 
    390   //  /** 
    391   //   * (Should only be called by garbage collector) - outdated method: now handled in cleanup 
    392   //   * 
    393   //   * Check if some threads have stopped. Enqueue their info for deletion. 
    394   //   * 
    395   //   * \param handle Port Handle 
    396   //   */ 
    397   //  /*static void cleanupThreads() { 
    398   //      synchronized(infos) { 
    399   //          for (int i = 0, n = infos.size(); i < n; i++) { 
    400   //              final ThreadLocalInfo tli = infos.get(i); 
    401   //              if (!tli.thread.isAlive()) { 
    402   //                  GarbageCollector.deleteDeferred(tli); 
    403   //                  infos.remove(i); 
    404   //                  i--; 
    405   //              } 
    406   //          } 
    407   //      } 
    408   //  }*/ 
    409   // 
    410  
    411   // 
    412   //  /** 
    413   //   * Cache port management data for specified port data 
    414   //   * 
    415   //   * \param data to cache management data for 
    416   //   */ 
    417   //  @Inline public PortDataManager cachePortData(PortData data) { 
    418   //      PortDataManager mgr = data.getManager(); 
    419   //      maskIndex = mgr.ownerRefCounter & 0x3; 
    420   //      counterMask = PortDataManager.refCounterMasks[maskIndex]; 
    421   //      counterIncrement = PortDataManager.refCounterIncrement[maskIndex]; 
    422   //      return mgr; 
    423   //  } 
    424  
    425249  /*! 
    426250   * \return Shared Pointer to List with all ThreadLocalInfo objects... necessary for clean cleaning up 
     
    442266    return thread_uid; 
    443267  } 
    444  
    445   //  /** 
    446   //   * \param pd return port data from other thread 
    447   //   */ 
    448   //  @Inline private void returnPortData(CCPortDataContainer<?> pd) { 
    449   //      if (pd.getOwnerThread() == ThreadUtil.getCurrentThreadId()) { 
    450   //          pd.releaseLock(); 
    451   //      } else { 
    452   //          returnedBuffers.enqueue(pd); 
    453   //      } 
    454   //  } 
    455  
    456   //  void reclaimReturnedBuffers() { 
    457   //      if (!returnedBuffers.isEmpty()) { // does not need to be synchronized, wa? 
    458   //          synchronized(returnedBuffers) { 
    459   //              for (int i = 0, n = returnedBuffers.size(); i < n; i++) { 
    460   //                  returnedBuffers.get(i).releaseLock(); 
    461   //              } 
    462   //          } 
    463   //      } 
    464   //  } 
    465268 
    466269  inline tCCPortDataContainer<>* GetUnusedBuffer(tDataType* data_type) 
     
    479282    } 
    480283    //      assert(pf.recycled); 
    481     //      //System.out.println("dq " + pf.getRegisterIndex()); 
    482284    //      assert(pf.next2.get().isDummy()); 
    483     //      pf.recycled = false; 
    484285    return pf; 
    485286  } 
  • portdatabase/tDataType.h

    r27 r57  
    6868  const char* const rtti_name; // pointer to RTTI name - unambiguous according to gcc docs 
    6969 
    70   /*! Methods for serialization */ 
    71   //public enum SerializationMethod { Custom, Memcpy } 
    72  
    73   /*! Is this a custom serializable data type (currently prerequisite) */ 
    74   //@Const private final SerializationMethod serialization = SerializationMethod.Custom; 
    75  
    7670  /*! Current default minimum network update interval for type im ms */ 
    7771  int16 update_time; 
     
    116110  } 
    117111 
    118   //  @JavaOnly 
    119   //  public DataType(/*short uid,*/ String name, @AutoPtr PortDataFactory factory, boolean ccType/*, SerializationMethod serialization*/) { 
    120   //      //this.serialization = serialization; 
    121   //      //dataTypeUid = uid; 
    122   //      javaClass = null; 
    123   //      this.factory = factory; 
    124   //      this.ccType = ccType 
    125   //      ; 
    126   //  } 
    127  
    128112  /*! 
    129113   * \return Create new instance of data type 
     
    208192    return methods; 
    209193  } 
    210  
    211   //  @Override 
    212   //  public void deserialize(CoreInput is) { 
    213   //      throw new RuntimeException("Not intended"); 
    214   //  } 
    215   // 
    216   //  @Override 
    217   //  public void serialize(CoreBuffer os) { 
    218   //      PortInfo.serializeDataType(this, os); 
    219   //  } 
    220194 
    221195  /*! 
     
    331305  } 
    332306 
    333   //  SerializationMethod getSerialization(CoreSerializable* cs) { 
    334   //      return Custom; 
    335   //  } 
    336   //  SerializationMethod getSerialization(void* cs) { 
    337   //      return Memcpy; 
    338   //  } 
    339  
    340307  /*! 
    341308   * \return Uid of data type 
  • portdatabase/tDataTypeRegister.h

    r27 r57  
    6565  int16 next_cCData_type_uid; 
    6666 
    67   /*! Cached Port creation info for entry ports */ 
    68   //private static final PortCreationInfo entryPortPci = new PortCreationInfo(PortFlags.INPUT_PORT, Unit.ms); 
    69  
    70   //  static { 
    71   //      // init Data Types 
    72   //      try { 
    73   ////            for (Class<?> cl : Files.getPackageClasses(DataTypeRegister2.class, "../datatype")) { 
    74   ////                if (RuntimeSettings.DISPLAY_DATATYPE_INIT) { 
    75   ////                    System.out.println("Initializing data type: " + cl.getName()); 
    76   ////                } 
    77   ////                addClass(cl); 
    78   ////                /*for (Class<?> cl2 : cl.getClasses()) { 
    79   ////                    addClass(cl2); 
    80   ////                }*/ 
    81   ////            } 
    82   //          // temporary 
    83   //          dataTypes[0] = new DataType((short)0, CoreNumberContainer.class); 
    84   //      } catch (Exception e) { 
    85   //          throw new RuntimeException(e); 
    86   //      } 
    87   //  } 
    88  
    8967  /*! Log domain for this class */ 
    9068  RRLIB_LOG_CREATE_NAMED_DOMAIN(log_domain, "data_types"); 
     
    217195  } 
    218196 
    219   //  /** 
    220   //   * Add data type entry for class 
    221   //   * 
    222   //   * \param cl Class 
    223   //   */ 
    224   //  private static DataType addClass(Class<?> cl) { 
    225   //      try { 
    226   //          if ((PortData.class.isAssignableFrom(cl) || CustomSerialization.class.isAssignableFrom(cl))) { 
    227   //              Class<PortData> dataClass = (Class<PortData>)cl; 
    228   //              short suid = getDataTypeUid(dataClass); 
    229   //              if (dataTypes[suid] != null) { 
    230   //                  throw new RuntimeException("There are two PortData classes with the same Uid " + suid + " (" + cl.getName() + " and " + dataTypes[suid].dataType.getName() + ")."); 
    231   //              } 
    232   //              dataTypes[suid] = new DataType(dataClass, suid); 
    233   // 
    234   //              return dataTypes[suid]; 
    235   //          } 
    236   //          return null; 
    237   //      } catch (Exception e) { 
    238   //          e.printStackTrace(); 
    239   //      } 
    240   //      return null; 
    241   //  } 
    242  
    243197  /*! 
    244198   * Get Data Type for specified uid. 
     
    306260  } 
    307261 
    308   /*! 
    309    * Returns serialVersionUID of specified class (if between 0 and 32K) 
    310    * 
    311    * \param cl Class 
    312    * \return serialVersionUID 
    313    */ 
    314 //  private static short getDataTypeUid(Class<? extends PortData> cl) { 
    315 //      if (!Modifier.isAbstract(cl.getModifiers())) { 
    316 //          long uid = ObjectStreamClass.lookup(cl).getSerialVersionUID();  // hopefully this will work in applets 
    317 //          if (uid > Short.MAX_VALUE || uid < 0) { 
    318 //              throw new RuntimeException("The serialVersionUID of PortData classes must lie between 0 and " + Short.MAX_VALUE + " (Class: " + cl.getSimpleName() + ")"); 
    319 //          } 
    320 //          return (short)uid; 
    321 //      } else { 
    322 //          PortData.InterfaceSpec i = cl.getAnnotation(PortData.InterfaceSpec.class); 
    323 //          if (i == null) { 
    324 //              throw new RuntimeException("Interfaces must implement PortData.InterfaceSpec. " + cl.getSimpleName() + " doesn't."); 
    325 //          } 
    326 //          return i.uid(); 
    327 //      } 
    328 //  } 
    329  
    330262}; 
    331263 
  • portdatabase/tSerializableReusable.h

    r27 r57  
    4343  tSerializableReusable() {} 
    4444 
    45   //  /** Id of Thread responsible of recycling this object - responsibility may me transferred */ 
    46   //  public volatile long responsibleThread; 
    47  
    48   //  /** Is current thread responsible of recycling object? */ 
    49   //  public boolean isResponsible() { 
    50   //      return ThreadUtil.getCurrentThreadId() == responsibleThread; 
    51   //  } 
    52   // 
    53   //  public void recycle() { 
    54   //      responsibleThread = -1; 
    55   //      super.recycle(); 
    56   //  } 
    57  
    5845  /*! 
    5946   * Recycle call object - after calling this method, object is available in ReusablesPool it originated from 
  • tFrameworkElement.h

    r56 r57  
    168168public: 
    169169 
    170   /*! RuntimeElement as TreeNode (only available if set in RuntimeSettings) */ 
    171   //@JavaOnly private final DefaultMutableTreeNode treeNode; 
    172  
    173   /*! State Constants */ 
    174   //public enum State { CONSTRUCTING, READY, DELETED }; 
    175  
    176   /*! Element's state */ 
    177   //protected volatile State state = State.CONSTRUCTING; 
    178  
    179   /*! Type Constants */ 
    180   //public enum Type { STANDARD_ELEMENT, RUNTIME, PORT } 
    181  
    182   /*! 
    183    * Element's handle in local runtime environment 
    184    * ("normal" elements have negative handle, while ports have positive ones) 
    185    * Now stored in objMutex 
    186    */ 
    187   //@Const protected final int handle; 
    188  
    189170  /*! 
    190171   * Defines lock order in which framework elements can be locked. 
     
    196177   */ 
    197178  mutable util::tMutexLockOrder obj_mutex; 
    198  
    199   /*! This flag is set to true when the element has been initialized */ 
    200   //private boolean initialized; 
    201  
    202   /*! This flag is set to true when element is deleted */ 
    203   //protected volatile boolean deleted; 
    204  
    205   /*! Is RuntimeElement member of remote runtime; -1 = unknown, 0 = no, 1 = yes */ 
    206   //private int remote = -1; 
    207  
    208   /*! 
    209    * List with owned ports. 
    210    * 
    211    * Methods that want to prevent a current port value (that this RuntimeElement manages) 
    212    * being outdated and reused while they are 
    213    * asynchronously getting it should synchronize with this list. 
    214    * Port methods do this. 
    215    * 
    216    * The owner module will synchronize on this list, every time it updates valuesBeforeAreUnused 
    217    * variable of the ports. 
    218    */ 
    219   //protected final SafeArrayList<Port<?>> ownedPorts; 
    220  
    221   /*! Main Thread. This thread can write to the runtime element's ports without synchronization */ 
    222   //protected Thread mainThread; 
    223179 
    224180  /*! Log domain for this class */ 
     
    311267   */ 
    312268  bool GetQualifiedNameImpl(util::tStringBuilder& sb, const tLink* start, bool force_full_link) const; 
    313  
    314   //  /** 
    315   //   * Initialize this framework element and all framework elements in sub tree that were created by this thread 
    316   //   * and weren't initialized already - provided that the parent element already is initialized. 
    317   //   * (If parent is not initialized, nothing happens) 
    318   //   * 
    319   //   * Initializing must be done prior to using framework elements - and in order to them being published. 
    320   //   */ 
    321   //  public void initIfParentIs() { 
    322   //      FrameworkElement parent = getParent(); 
    323   //      synchronized(parent.children) { 
    324   //          if (parent.isReady()) { 
    325   //              init(); 
    326   //          } 
    327   //      } 
    328   //  } 
    329269 
    330270  /*! 
     
    441381  virtual void PrintStructure(int indent, rrlib::logging::tLogStream& output); 
    442382 
    443   //  /** 
    444   //   * Called whenever an asynchronous call returns. 
    445   //   * May be overriden/implemented by subclasses. 
    446   //   * Default behaviour is throwing an Exception. 
    447   //   * (Should only be called by framework-internal classes) 
    448   //   * 
    449   //   * \param pc Call Object containing various parameters 
    450   //   */ 
    451   //  @InCppFile 
    452   //  @Virtual public void handleCallReturn(AbstractCall pc) { 
    453   //      throw new RuntimeException("This FrameworkElement cannot handle call returns"); 
    454   //  } 
    455  
    456383  /*! 
    457384   * Publish updated edge information 
     
    546473 
    547474  /*! 
    548    * \return RuntimeElement as TreeNode (only available if set in RuntimeSettings) 
    549    */ 
    550   /*@JavaOnly public DefaultMutableTreeNode asTreeNode() { 
    551       return treeNode; 
    552   }*/ 
    553  
    554   /*! 
    555    * \param manages_ports Is RuntimeElement responsible for releasing unused port values? 
    556    */ 
    557   //@SuppressWarnings("unchecked") 
    558   //public FrameworkElement(String description, boolean managesPorts, Thread mainThread) { 
    559   //ownedPorts = managesPorts ? new SafeArrayList<Port<?>>() : null; 
    560   //mainThread = mainThread == null ? (managesPorts ? Thread.currentThread() : null) : mainThread; 
    561   //} 
    562  
    563   //    /** 
    564   //     * \return Tree Node representation of this runtime object 
    565   //     */ 
    566   //    @JavaOnly protected DefaultMutableTreeNode createTreeNode() { 
    567   //        return new DefaultMutableTreeNode(primary.description); 
    568   //    } 
    569  
    570   /*! 
    571475   *  same as below - 
    572476   *  except that we return a const char* in C++ - this way, no memory needs to be allocated 
     
    579483   */ 
    580484  tFrameworkElement* GetChild(const util::tString& name) const; 
    581  
    582   //  /** 
    583   //   * Does element with specified qualified name exist? 
    584   //   * 
    585   //   * \param name (relative) Qualified name 
    586   //   * \return Answer 
    587   //   */ 
    588   //  public boolean elementExists(@Const @Ref String name) { 
    589   //      return getChildElement(name, false) != null; 
    590   //  } 
    591485 
    592486  /*! 
     
    630524  } 
    631525 
    632   //  ///////////////////// real factory methods ///////////////////////// 
    633   //  //public Port<?> 
    634   // 
    635   //  protected NumberPort addNumberPort(boolean output, @Const @Ref String description, @CppDefault("CoreNumber::ZERO") @Const @Ref Number defaultValue, @CppDefault("NULL") Unit unit) { 
    636   //      return addNumberPort(output ? PortFlags.OUTPUT_PORT : PortFlags.INPUT_PORT, description, defaultValue, unit); 
    637   //  } 
    638   // 
    639   //  protected NumberPort addNumberPort(int flags, @Const @Ref String description, @CppDefault("CoreNumber::ZERO") @Const @Ref Number defaultValue, @CppDefault("NULL") Unit unit) { 
    640   //      PortCreationInfo pci = new PortCreationInfo(description, this, flags); 
    641   //      //PortDataCreationInfo.get().set(DataTypeRegister2.getDataTypeEntry(CoreNumberContainer.class), owner, prototype); 
    642   //      //pci.defaultValue = new CoreNumberContainer(new CoreNumber2(defaultValue, unit)); 
    643   //      pci.unit = unit; 
    644   //      //pci.parent = this; 
    645   //      NumberPort np = new NumberPort(pci); 
    646   //      np.getDefaultBuffer().setValue(defaultValue, unit != null ? unit : Unit.NO_UNIT); 
    647   //      //addChild(np); 
    648   //      return np; 
    649   //  } 
    650   // 
    651   //  ///////////////////// convenience factory methods ///////////////////////// 
    652   //  @JavaOnly public NumberPort addNumberInputPort(@Const @Ref String description) { 
    653   //      return addNumberInputPort(description, CoreNumber.ZERO, Unit.NO_UNIT); 
    654   //  } 
    655   //  @JavaOnly public NumberPort addNumberInputPort(@Const @Ref String description, @Const @Ref Number defaultValue) { 
    656   //      return addNumberInputPort(description, defaultValue, Unit.NO_UNIT); 
    657   //  } 
    658   //  @JavaOnly public NumberPort addNumberInputPort(@Const @Ref String description, @Ptr Unit unit) { 
    659   //      return addNumberInputPort(description, CoreNumber.ZERO, unit); 
    660   //  } 
    661   //  public NumberPort addNumberInputPort(@Const @Ref String description, @CppDefault("CoreNumber::ZERO") @Const @Ref Number defaultValue, @CppDefault("NULL") @Ptr Unit unit) { 
    662   //      return addNumberPort(false, description, defaultValue, unit); 
    663   //  } 
    664   //  /*public NumberPort addNumberInputPort(String description, Number defaultValue, Unit unit, double min, double max) { 
    665   // 
    666   //  }*/ 
    667   // 
    668   //  @JavaOnly public NumberPort addNumberOutputPort(@Const @Ref String description) { 
    669   //      return addNumberOutputPort(description, CoreNumber.ZERO, Unit.NO_UNIT); 
    670   //  } 
    671   //  @JavaOnly public NumberPort addNumberOutputPort(@Const @Ref String description, @Const @Ref Number defaultValue) { 
    672   //      return addNumberOutputPort(description, defaultValue, Unit.NO_UNIT); 
    673   //  } 
    674   //  @JavaOnly public NumberPort addNumberOutputPort(@Const @Ref String description, @Ptr Unit unit) { 
    675   //      return addNumberOutputPort(description, CoreNumber.ZERO, unit); 
    676   //  } 
    677   //  public NumberPort addNumberOutputPort(@Const @Ref String description, @CppDefault("CoreNumber::ZERO") @Const @Ref Number defaultValue, @CppDefault("NULL") @Ptr Unit unit) { 
    678   //      return addNumberPort(true, description, defaultValue, unit); 
    679   //  } 
    680   // 
    681   //  public NumberPort addNumberProxyPort(boolean output, @Const @Ref String description, @CppDefault("CoreNumber::ZERO") @Const @Ref Number defaultValue, @CppDefault("NULL") @Ptr Unit unit) { 
    682   //      return addNumberPort(output ? PortFlags.OUTPUT_PROXY : PortFlags.INPUT_PROXY, description, defaultValue, unit); 
    683   //  } 
    684  
    685526  /*! 
    686527   * \return Element's handle in local runtime environment 
     
    789630  } 
    790631 
    791   //  /** 
    792   //   * Get all children with specified flags set/unset 
    793   //   * (Don't store this array for longer than possible 
    794   //   * 
    795   //   * \param result Children will be copied to this array (if there are more, array will be filled completely) 
    796   //   * \param checkFlags Flags to check 
    797   //   * \param checkResult The result the check has to have in order to add child to result 
    798   //   * \return Number of elements in result. 
    799   //   */ 
    800   //  public @SizeT int getChildrenFlagged(@Ref FrameworkElement[] result, int checkFlags, int checkResult) { 
    801   // 
    802   //  } 
    803  
    804632  /*! 
    805633   * (Use StringBuilder version if efficiency or real-time is an issue) 
     
    892720    return IsChildOf(re, false); 
    893721  } 
    894  
    895   //  /** 
    896   //   * \return Returns the element's uid, which is the concatenated description of it and all parents. 
    897   //   * It is only valid as long as the structure and descriptions stay the same. 
    898   //   */ 
    899   //  public String getUid() { 
    900   //      return getUid(false, RuntimeEnvironment.class).toString(); 
    901   //  } 
    902   // 
    903   //  /** 
    904   //   * \return Returns the element's uid, which is the concatenated description of it and all parents. 
    905   //   * In case it is part of a remote runtime environment, the uid in the remote environment is returned. 
    906   //   */ 
    907   //  public String getOriginalUid() { 
    908   //      return getUid(false, core.Runtime.class).toString(); 
    909   //  } 
    910   // 
    911   //  /** 
    912   //   * Optimized helper method for Uid creation 
    913   //   * 
    914   //   * \param includeSeparator Include separator at end? 
    915   //   * \param upToParent Type of parent up to which uid is created 
    916   //   * \return Returns the element's uid, which is the concatenated description of it and all parents. 
    917   //   */ 
    918   //  protected StringBuilder getUid(boolean includeSeparator, Class<?> upToParent) { 
    919   //      StringBuilder temp = null; 
    920   //      if (upToParent.isAssignableFrom(getClass())) { 
    921   //          return new StringBuilder(); 
    922   //      } else if (parent == null || upToParent.isAssignableFrom(parent.getClass())) { 
    923   //          temp = new StringBuilder(description); 
    924   //      } else { 
    925   //          temp = parent.getUid(true, upToParent).append(description); 
    926   //      } 
    927   //      if (includeSeparator) { 
    928   //          temp.append(getUidSeparator()); 
    929   //      } 
    930   //      return temp; 
    931   //  } 
    932  
    933   //  /** 
    934   //   * \return Is RuntimeElement member of remote runtime 
    935   //   */ 
    936   //  public boolean isRemote() { 
    937   //      if (remote >= 0) { 
    938   //          return remote > 0; 
    939   //      } 
    940   //      if (this instanceof core.Runtime) { 
    941   //          remote = (this instanceof RuntimeEnvironment) ? 0 : 1; 
    942   //          return remote > 0; 
    943   //      } 
    944   //      remote = parent.isRemote() ? 1 : 0; 
    945   //      return remote > 0; 
    946   //  } 
    947   // 
    948   //  /** 
    949   //   * \return Character Sequence that separates the UID after this class; 
    950   //   */ 
    951   //  protected char getUidSeparator() { 
    952   //      return '.'; 
    953   //  } 
    954   // 
    955   //  /** 
    956   //   * \return Returns true when element is deleted 
    957   //   */ 
    958   //  public boolean isDeleted() { 
    959   //      return deleted; 
    960   //  } 
    961   // 
    962   //  /** 
    963   //   * Get all tasks from children... for thread migration... not a very nice way of doing it... but well 
    964   //   */ 
    965   //  protected void collectTasks(List<Task> t) { 
    966   //      List<FrameworkElement> l = getChildren(); 
    967   //      for (int i = 0; i < l.size(); i++) { 
    968   //          FrameworkElement child = l.get(i); 
    969   //          if (child != null) { 
    970   //              child.collectTasks(t); 
    971   //          } 
    972   //      } 
    973   //  } 
    974   // 
    975   //  /** 
    976   //   * \return Parent 
    977   //   */ 
    978   //  public FrameworkElement getParent() { 
    979   //      return parent; 
    980   //  } 
    981   // 
    982   //  /** 
    983   //   * \return Umodifiable list of children. Can and should be used for fast 
    984   //   * safe unsynchronized iteration. May contain null-entries. 
    985   //   */ 
    986   //  public List<FrameworkElement> getChildren() { 
    987   //      return children.getFastUnmodifiable(); 
    988   //  } 
    989   // 
    990   //  /** 
    991   //   * \param childIndex Index 
    992   //   * \return Child at specified index 
    993   //   */ 
    994   //  public FrameworkElement getChildAt(int childIndex) { 
    995   //      return children.get(childIndex); 
    996   //  } 
    997   // 
    998   //  /** 
    999   //   * Get Child with specified UID 
    1000   //   * (optimized so that no new Strings need to be created in relative mode) 
    1001   //   * 
    1002   //   * \param uid UID 
    1003   //   * \param b absolute UID? (rather than a relative one) 
    1004   //   * \return Child (null if does not exists) 
    1005   //   */ 
    1006   //  public FrameworkElement getChild(String uid, boolean absolute) { 
    1007   //      if (absolute) { 
    1008   //          String myUid = getUid(true, RuntimeEnvironment.class).toString(); 
    1009   //          if (!uid.startsWith(myUid)) { 
    1010   //              return uid.equals(getUid()) ? this : null; 
    1011   //          } else if (uid.length() == myUid.length()) { 
    1012   //              return this; 
    1013   //          } 
    1014   //          uid = uid.substring(myUid.length());  // cut off separator 
    1015   //      } 
    1016   // 
    1017   //      // uid now relative 
    1018   //      List<FrameworkElement> l = getChildren(); 
    1019   //      for (int i = 0; i < l.size(); i++) { 
    1020   //          FrameworkElement child = l.get(i); 
    1021   //          if (child == null) { 
    1022   //              continue; 
    1023   //          } 
    1024   //          String childDesc = child.getDescription(); 
    1025   //          if (uid.length() < childDesc.length()) { 
    1026   //              continue; 
    1027   //          } else if (uid.length() >= childDesc.length()) { 
    1028   //              if (uid.startsWith(childDesc)) { 
    1029   //                  if (uid.length() == childDesc.length()) { 
    1030   //                      return child; 
    1031   //                  } else if (uid.charAt(childDesc.length()) == child.getUidSeparator()){ 
    1032   //                      return child.getChild(uid.substring(childDesc.length() + 1), false); 
    1033   //                  } 
    1034   //              } 
    1035   //          } 
    1036   //      } 
    1037   //      return null; 
    1038   //  } 
    1039   // 
    1040   //  /** 
    1041   //   * Get All children of the specified class 
    1042   //   * 
    1043   //   * \param childClass Class 
    1044   //   * \return List of children 
    1045   //   */ 
    1046   //  public <T extends FrameworkElement> List<T> getAllChildren(Class<T> childClass) { 
    1047   //      List<T> result = new ArrayList<T>(); 
    1048   //      getAllChildrenHelper(result, childClass); 
    1049   //      return result; 
    1050   //  } 
    1051   // 
    1052   //  /** 
    1053   //   * Recursive helper function to above function 
    1054   //   * 
    1055   //   * \param result List with results (only needs to be allocated once) 
    1056   //   * \param childClass Class 
    1057   //   */ 
    1058   //  @SuppressWarnings("unchecked") 
    1059   //  private <T extends FrameworkElement> void getAllChildrenHelper(List<T> result, Class<T> childClass) { 
    1060   //      for (int i = 0, n = children.size(); i < n; i++) { 
    1061   //          FrameworkElement child = children.get(i); 
    1062   //          if (child == null) { 
    1063   //              continue; 
    1064   //          } 
    1065   //          if (childClass == null || childClass.isAssignableFrom(child.getClass())) { 
    1066   //              result.add((T)child); 
    1067   //          } 
    1068   //          child.getAllChildrenHelper(result, childClass); 
    1069   //      } 
    1070   //  } 
    1071   // 
    1072   //  /** 
    1073   //   * Serialize the runtime's uid to the specified output stream. 
    1074   //   * This is very efficient, since no new objects need to be allocated 
    1075   //   * to construct the uid 
    1076   //   * 
    1077   //   * \param oos Stream to serialize to. 
    1078   //   */ 
    1079   //  public void serializeUid(CoreOutputStream oos) throws IOException  { 
    1080   //      serializeUid(oos, true); 
    1081   //  } 
    1082   // 
    1083   //  /** 
    1084   //   * Helper method for above 
    1085   //   * 
    1086   //   * \param oos Stream to serialize to. 
    1087   //   * \param firstCall Object the method was called on? 
    1088   //   */ 
    1089   //  protected void serializeUid(CoreOutputStream oos, boolean firstCall) throws IOException { 
    1090   //      if (parent != null) { 
    1091   //          parent.serializeUid(oos, false); 
    1092   //      } 
    1093   //      oos.write8BitStringPart(description); 
    1094   //      if (firstCall) { 
    1095   //          oos.write8BitString(""); // end string 
    1096   //      } else { 
    1097   //          oos.writeByte(getUidSeparator()); 
    1098   //      } 
    1099   //  } 
    1100   // 
    1101   //  /** 
    1102   //   * \return Methods that want to prevent a current port value (that this RuntimeElement manages) 
    1103   //   * being outdated and reused while they are 
    1104   //   * asynchronously getting it should synchronize with this object. 
    1105   //   */ 
    1106   //  public Object getPortManagerSynchInstance() { 
    1107   //      return ownedPorts; 
    1108   //  } 
    1109   // 
    1110   //  /** 
    1111   //   * \return Is RuntimeElement responsible for releasing unused port values? 
    1112   //   */ 
    1113   //  public boolean isPortManager() { 
    1114   //      return ownedPorts != null; 
    1115   //  } 
    1116   // 
    1117   //  /** 
    1118   //   * \param p Port that this RuntimeElement owns 
    1119   //   */ 
    1120   //  protected void addOwnedPort(Port<?> p) { 
    1121   //      if (isPortManager()) { 
    1122   //          if (p.isOutputPort()) { 
    1123   //              p.setMainThread(getMainThread()); 
    1124   //          } 
    1125   //          ownedPorts.add(p); 
    1126   //      } else { 
    1127   //          parent.addOwnedPort(p); 
    1128   //      } 
    1129   //  } 
    1130   // 
    1131   //  /** 
    1132   //   * \param p Port that this RuntimeElement does not own any longer 
    1133   //   */ 
    1134   //  protected void removeOwnedPort(Port<?> p) { 
    1135   //      if (isPortManager()) { 
    1136   //          ownedPorts.remove(p); 
    1137   //      } else { 
    1138   //          parent.removeOwnedPort(p); 
    1139   //      } 
    1140   //  } 
    1141   // 
    1142   //  /** 
    1143   //   * \return Main Thread. This thread can write to the runtime element's ports without synchronization 
    1144   //   */ 
    1145   //  public Thread getMainThread() { 
    1146   //      return mainThread; 
    1147   //  } 
    1148   // 
    1149   //  /** 
    1150   //   * \param Main Thread. This thread can write to the runtime element's ports without synchronization 
    1151   //   */ 
    1152   //  public void setMainThread(Thread mainThread) { 
    1153   //      // update main thread of ports 
    1154   //      this.mainThread = mainThread; 
    1155   //      if (isPortManager()) { 
    1156   //          synchronized(ownedPorts) { 
    1157   //              for (int i = 0; i < ownedPorts.size(); i++) { 
    1158   //                  PortBase<?> p = ownedPorts.get(i); 
    1159   //                  if (p != null && p != this) { 
    1160   //                      ownedPorts.get(i).setMainThread(mainThread); 
    1161   //                  } 
    1162   //              } 
    1163   //          } 
    1164   //      } 
    1165   //  } 
    1166722 
    1167723  /*! 
  • tLinkEdge.h

    r27 r57  
    138138  } 
    139139 
    140 //  /** 
    141 //   * Called by RuntimeEnvironment when link that this object is obviously interested in has been removed 
    142 //   * 
    143 //   * \param re RuntimeEnvironment 
    144 //   * \param link Link that has been added 
    145 //   * \param port port linked to 
    146 //   */ 
    147 //  void linkRemoved(RuntimeEnvironment re, String link, AbstractPort port) { 
    148 //      // do nothing... currently 
    149 //  } 
    150  
    151140}; 
    152141 
  • tRuntimeEnvironment.cpp

    r56 r57  
    6565  instance_raw_ptr = this; 
    6666  active = true; 
    67  
    68   //      for (int i = 0; i < RuntimeSettings.NUM_OF_LOOP_THREADS; i++) { 
    69   //          loopThreads.add(new CoreLoopThread(i, i < RuntimeSettings.SELF_UPDATING_LOOP_THREADS)); 
    70   //      } 
    71   //      for (int i = 0; i < RuntimeSettings.NUM_OF_EVENT_THREADS; i++) { 
    72   //          eventThreads.add(new CoreEventThread(i)); 
    73   //      } 
    74  
    75   // init runtime settings 
    76   //settings = new RuntimeSettings(); 
    77   //addChild(settings); 
    78  
    79   // init Plugins etc. 
    80   //Plugins.getInstance().addPluginsFromApplicationDir(); 
    8167} 
    8268 
     
    181167  tUnit::StaticInit();  // can safely be done first 
    182168  tConstant::StaticInit();  // needs to be done after unit 
    183   //      CoreNumber.staticInit(); // can be after data type register has been created 
    184169  util::tTime::GetInstance();  // (possibly) init timing thread 
    185170  util::tGarbageCollector::CreateAndStartInstance(); 
    186   //      MethodCall.staticInit(); 
    187   //      PullCall.staticInit(); 
    188171  ::std::tr1::shared_ptr<util::tSimpleListWithMutex<tThreadLocalCache*> > infos_lock = tThreadLocalCache::StaticInit();  // can safely be done first 
    189172  tMethodCallSyncher::StaticInit();  // dito 
    190173  util::tBoundedQElementContainer::StaticInit(); 
    191174  util::tChunkedBuffer::StaticInit(); 
    192   tStreamCommitThread::StaticInit(); 
    193   //TransactionPacket.staticInit();  // should be done before any ports/elements are added 
     175  tStreamCommitThread::StaticInit();  // should be done before any ports/elements are added 
    194176 
    195177  new tRuntimeEnvironment(); // should be done before any ports/elements are added 
  • tRuntimeEnvironment.h

    r30 r57  
    110110  tRegistry registry; 
    111111 
    112   // 
    113   //  // Static elements to delete after all elements in runtime environment 
    114   //  std::tr1::shared_ptr<util::SimpleList<finroc::util::Object*> > deleteLastList; 
    115   // 
    116  
    117   /*! Loop threads in this runtime */ 
    118   //private final SimpleList<CoreLoopThread> loopThreads = new SimpleList<CoreLoopThread>(); 
    119  
    120   /*! Event threads in this runtime */ 
    121   //private final SimpleList<CoreEventThread> eventThreads = new SimpleList<CoreEventThread>(); 
    122  
    123   /*! Global list of all ports (also place holders for those that are currently not available) */ 
    124   //private final Map<String, PortContainer> ports = new FastMap<String, PortContainer>(); 
    125  
    126   /*! 
    127    * Global list of all ports (also place holders for those that are currently not available) 
    128    * allows accessing ports with simple index. This index is unique during runtime. 
    129    * List will grow... somewhat memory leak like... but still with 100.000 different port uids it's only 400kb 
    130    * 
    131    * Thread-safe for iteration. 
    132    */ 
    133   //private final FastTable<PortContainer> indexedPorts = new FastTable<PortContainer>(); 
    134  
    135   /*! List with Ports that actually exists - thread-safe for iteration - may contain null entries */ 
    136   //private final SafeArrayList<Port<?>> existingPorts = new SafeArrayList<Port<?>>(); 
    137  
    138   /*! Global list of all modules (also place holders for those that are currently not available) */ 
    139   //private final FastMap<String, ModuleContainer> modules = new FastMap<String, ModuleContainer>(); 
    140  
    141   /*! Number of active modules */ 
    142   //private int activeModuleCount; 
    143  
    144   /*! All edges in runtime environment */ 
    145   //private final List<Edge> edges = new ArrayList<Edge>(); 
    146  
    147   /*! Flexible edges in runtime environment */ 
    148   //private final List<FlexEdge> flexEdges = new ArrayList<FlexEdge>(); 
    149  
    150112  /*! Singleton instance of Runtime environment - shared pointer so that is cleanly deleted at shutdown */ 
    151113  static ::std::tr1::shared_ptr<tRuntimeEnvironment> instance; 
     
    165127public: 
    166128 
    167   /*! Runtime settings */ 
    168   //private final RuntimeSettings settings; 
    169  
    170   /*! Runtime listeners and Parameters */ 
    171   //private final ListenerManager listeners = new ListenerManager(); 
    172   //private final Byte ADD = 1, REMOVE = 2; 
    173  
    174   //  /** Links to framework elements */ 
    175   //  private final ConcurrentMap<String, AbstractPort> links = new ConcurrentMap<String, AbstractPort>(); 
    176  
    177   //  /** True, when Runtime environment is shutting down */ 
    178   //  public static boolean shuttingDown = false; 
    179  
    180129  /*! Framework element that contains all framework elements that have no parent specified */ 
    181130  ::finroc::core::tFrameworkElement* unrelated; 
     
    183132private: 
    184133 
    185   //  @SuppressWarnings("unused") 
    186   //  @InCppFile 
    187   //  private void stopStreamThread() { 
    188   //      StreamCommitThread.staticStop(); 
    189   //  } 
    190  
    191   //@Init("deleteLastList(new util::SimpleList<finroc::util::Object*>())") 
    192134  tRuntimeEnvironment(); 
    193135 
    194136protected: 
    195  
    196   //  /** 
    197   //   * (Should only be called by AbstractPort) 
    198   //   * Create link to port 
    199   //   * 
    200   //   * \param port Port 
    201   //   * \param linkName Name of link 
    202   //   */ 
    203   //  public synchronized void link(AbstractPort port, String linkName) { 
    204   //      assert(!links.contains(linkName)); 
    205   //      links.put(linkName, port); 
    206   // 
    207   //      // notify link listeners 
    208   // 
    209   //      for (@SizeT int i = 0; i < listeners.size(); i++) { 
    210   //          listeners.get(i).linkAdded(linkName, port); 
    211   //      } 
    212   // 
    213   //      // notify edges 
    214   //      LinkEdge interested = linkEdges.getPtr(linkName); 
    215   //      while(interested != null) { 
    216   //          interested.linkAdded(this, linkName, port); 
    217   //      } 
    218   //  } 
    219  
    220   //  /** 
    221   //   * (Should only be called by AbstractPort) 
    222   //   * Remove link to port 
    223   //   * 
    224   //   * \param linkName Name of link 
    225   //   */ 
    226   //  public synchronized void removeLink(String linkName) { 
    227   //      AbstractPort ap = links.remove(linkName); 
    228   // 
    229   //      // notify link listeners 
    230   //      for (@SizeT int i = 0; i < linkListeners.size(); i++) { 
    231   //          linkListeners.get(i).linkRemoved(linkName, ap); 
    232   //      } 
    233   //  } 
    234137 
    235138  /*! 
     
    280183    active = false; 
    281184    util::tThread::StopThreads(); 
    282     //shuttingDown = true; 
    283     //util::GarbageCollector::deleteGarbageCollector(); // safer, this way 
    284185    DeleteChildren(); 
    285186    instance_raw_ptr = NULL; 
    286  
    287     //      // delete thread local caches mainly 
    288     //      for (size_t i = 0; i < deleteLastList->size(); i++) { 
    289     //          delete deleteLastList->get(i); 
    290     //      } 
    291     //      deleteLastList->clear(); 
    292     //      deleteLastList._reset(); 
    293     // stopStreamThread(); 
    294     // instance = NULL; will happen automatically 
    295187  } 
    296188 
     
    301193   */ 
    302194  static tRuntimeEnvironment* GetInstance(); 
    303  
    304   //  /** 
    305   //   * (should only be called by thread local-cache) 
    306   //   * get port by raw index 
    307   //   * 
    308   //   * \param i Raw index 
    309   //   * \return Port 
    310   //   */ 
    311   //  public AbstractPort getPortByRawIndex(int i) { 
    312   //      return ports.getByRawIndex(i); 
    313   //  } 
    314195 
    315196  /*! 
     
    361242  void MarkElementDeleted(tFrameworkElement* fe); 
    362243 
    363   //  /** 
    364   //   * \return Iterator to iterate over links 
    365   //   */ 
    366   //  public ConcurrentMap<String, AbstractPort>.MapIterator getLinkIterator() { 
    367   //      return links.getIterator(); 
    368   //  } 
    369  
    370   //  /** 
    371   //   * Delete this object after all Framework elements 
    372   //   */ 
    373   //  static void deleteLast(@Ptr Object t) { 
    374   // 
    375   //      if (instance == NULL || instance->deleteLastList._get() == NULL) { 
    376   //          delete t; 
    377   //      } else { 
    378   //          instance->deleteLastList->add(t); 
    379   //      } 
    380   // 
    381   //  } 
    382  
    383244  /*! 
    384245   * Called before a framework element is initialized - can be used to create links etc. to this element etc. 
     
    387248   */ 
    388249  void PreElementInit(tFrameworkElement* element); 
    389  
    390   //  @Override 
    391   //  protected void serializeUid(CoreOutputStream oos, boolean firstCall) throws IOException { 
    392   //      return;  // do not include Runtime Description in UIDs 
    393   //  } 
    394   // 
    395   //  /** 
    396   //   * \return Returns unmodifiable list of Ports. 
    397   //   */ 
    398   //  public List<PortContainer> getPorts() { 
    399   //      return indexedPorts.unmodifiable(); 
    400   //  } 
    401   // 
    402   //  /** 
    403   //   * \param index Port Index 
    404   //   * \return Returns PortContainer with specified global index 
    405   //   */ 
    406   //  public PortContainer getPort(int index) { 
    407   //      return indexedPorts.get(index); 
    408   //  } 
    409  
    410   //  /** 
    411   //   * \return Runtime Settings module 
    412   //   */ 
    413   //  public RuntimeSettings getSettings() { 
    414   //      return settings; 
    415   //  } 
    416   // 
    417   // 
    418   //  private class ListenerManager extends WeakRefListenerManager<RuntimeListener> { 
    419   // 
    420   //      @Override 
    421   //      protected void notifyObserver(RuntimeListener observer, Object... param) { 
    422   //          if (param[0] == ADD) { 
    423   //              observer.portAdded((Port<?>)param[1]); 
    424   //          } else { 
    425   //              observer.portRemoved((Port<?>)param[1]); 
    426   //          } 
    427   //      } 
    428   //  } 
    429   // 
    430   //  /** 
    431   //   * \param l 
    432   //   * @see core.util.WeakRefListenerManager#addListener(java.util.EventListener) 
    433   //   */ 
    434   //  public synchronized void addListener(RuntimeListener l, boolean applyExistingPorts) { 
    435   //      listeners.addListener(l); 
    436   //      if (applyExistingPorts) { 
    437   //          for (int i = 0, n = indexedPorts.size(); i < n; i++) { 
    438   //              Port<?> p = indexedPorts.get(i).getPort(); 
    439   //              if (p != null) { 
    440   //                  l.portAdded(p); 
    441   //              } 
    442   //          } 
    443   //      } 
    444   //  } 
    445   // 
    446   //  /** 
    447   //   * \param l 
    448   //   * @see core.util.WeakRefListenerManager#removeListener(java.util.EventListener) 
    449   //   */ 
    450   //  public synchronized void removeListener(RuntimeListener l) { 
    451   //      listeners.removeListener(l); 
    452   //  } 
    453   // 
    454   //  /** 
    455   //   * \return Unmodifiable List with Ports that actually exists - thread-safe for iteration - may contain null entries 
    456   //   */ 
    457   //  public List<Port<?>> getExistingPorts() { 
    458   //      return existingPorts.getFastUnmodifiable(); 
    459   //  } 
    460   // 
    461   //  /** 
    462   //   * \return the activeModuleCount 
    463   //   */ 
    464   //  public int getActiveModuleCount() { 
    465   //      return activeModuleCount; 
    466   //  } 
    467   // 
    468   //  public void resetLoopThreads() { 
    469   //      for (FastMap.Entry<String, ModuleContainer> e = modules.head(), end = modules.tail(); (e = e.getNext()) != end;) { 
    470   //          e.getValue().setLoopThreadInfo(null); 
    471   //      } 
    472   //  } 
    473250 
    474251  /*! 
     
    528305 
    529306  /*! 
    530    * Get Port container. Create if not yet existent. 
    531    * 
    532    * \param uid Port UID 
    533    * \return Port container 
    534    */ 
    535   /*public PortContainer getPort(String uid) { 
    536       PortContainer result = ports.get(uid); 
    537       if (result == null) { 
    538           synchronized (ports) {  // make port container creation thread-safe - only part in code that modifies ports and indexedPorts 
    539               result = ports.get(uid); 
    540               if (result == null) { 
    541                   result = new PortContainer(getModule(Module.getModulePartOfUID(uid)), uid); 
    542                   ports.put(uid, result); 
    543                   indexedPorts.add(result.getIndex(), result); // result.getIndex() should always be last index 
    544               } 
    545           } 
    546       } 
    547       return result; 
    548   }*/ 
    549  
    550   //  /** 
    551   //   * Adds edge 
    552   //   * 
    553   //   * \param sourceUid UID of source port 
    554   //   * \param destUid UID of destination port 
    555   //   * \return added edge 
    556   //   */ 
    557   //  public Edge addEdge(String sourceUid, String destUid) { 
    558   //      Edge e = new Edge(sourceUid, destUid); 
    559   //      addEdge(e); 
    560   //      return e; 
    561   //  } 
    562  
    563   /*! 
    564    * Add edge. 
    565    * 
    566    * \param e Edge 
    567    */ 
    568   //  public void addEdge(Edge e) { 
    569   //      synchronized(edges) { 
    570   //          edges.add(e); 
    571   //          e.register(getPort(e.getSourceUID()), getPort(e.getDestinationUID())); 
    572   //      } 
    573   //      reschedule(); 
    574   // 
    575   //  } 
    576   // 
    577   //  /** 
    578   //   * remove Edge 
    579   //   * 
    580   //   * \param e Edge 
    581   //   */ 
    582   //  public void removeEdge(Edge e) { 
    583   //      synchronized(edges) { 
    584   //          edges.remove(e); 
    585   //          e.unregister(edges); 
    586   //      } 
    587   //      reschedule(); 
    588   //  } 
    589   // 
    590   //  /** 
    591   //   * Add flexbible edge. 
    592   //   * 
    593   //   * \param e Edge 
    594   //   */ 
    595   //  public synchronized void addFlexEdge(FlexEdge e) { 
    596   //      flexEdges.add(e); 
    597   //      addListener(e, true); 
    598   //  } 
    599   // 
    600   //  /** 
    601   //   * remove flexible Edge 
    602   //   * 
    603   //   * \param e Edge 
    604   //   */ 
    605   //  public synchronized void removeFlexEdge(FlexEdge e) { 
    606   //      removeListener(e); 
    607   //      flexEdges.remove(e); 
    608   //      e.delete(); 
    609   //  } 
    610   // 
    611   //  /** 
    612   //   * Called by ports when they are initialized. 
    613   //   * Attaches them to PortContainer 
    614   //   * 
    615   //   * \param port Port to register 
    616   //   * \return PortContainer to which this port was attached 
    617   //   */ 
    618   //  public synchronized <T extends PortData> PortContainer registerPort(Port<T> port) { 
    619   //      PortContainer pc = getPort(port.getUid()); 
    620   //      port.setIndex(pc.getIndex()); 
    621   //      pc.setPort(port); 
    622   //      if (port.isShared()) { 
    623   //          settings.sharedPorts.add(new PortInfo(pc)); 
    624   //      } 
    625   //      existingPorts.add(port); 
    626   //      listeners.fireEvent(ADD, port); 
    627   //      reschedule(); 
    628   //      return pc; 
    629   //  } 
    630   // 
    631   //  /** 
    632   //   * Called by ports when they are deleted. 
    633   //   * Detaches them from PortContainer 
    634   //   * 
    635   //   * \param port Port to unregister 
    636   //   */ 
    637   //  public void unregisterPort(Port<?> port) { 
    638   //      listeners.fireEvent(REMOVE, port); 
    639   //      existingPorts.remove(port); 
    640   //      PortContainer pc = getPort(port.getUid()); 
    641   //      if (pc.getPort() == port) { 
    642   //          pc.setPort(null); 
    643   //          if (port.isShared()) { 
    644   //              settings.sharedPorts.remove(port.getIndex()); 
    645   //          } 
    646   //      } 
    647   //      reschedule(); 
    648   //  } 
    649  
    650   //  /** 
    651   //   * \param index Index 
    652   //   * \return Loop Thread with specified index 
    653   //   */ 
    654   //  public @Ref CoreLoopThread getLoopThread(int index) { 
    655   //      return loopThreads.get(index); 
    656   //  } 
    657   // 
    658   //  /** 
    659   //   * \param index Index 
    660   //   * \return Loop Thread with specified index 
    661   //   */ 
    662   //  public @Ref CoreEventThread getEventThread(int index) { 
    663   //      return eventThreads.get(index); 
    664   //  } 
    665  
    666   //  /** 
    667   //   * Called by modules when they are initialized. 
    668   //   * Attaches them to ModuleContainer 
    669   //   * 
    670   //   * \param port Module to register 
    671   //   */ 
    672   //  public void registerModule(Module module) { 
    673   //      ModuleContainer mc = getModule(module.getUid()); 
    674   //      mc.setModule(module); 
    675   //      activeModuleCount++; 
    676   //      reschedule(); 
    677   //  } 
    678   // 
    679   //  /** 
    680   //   * Get Module container. Create if not yet existent. 
    681   //   * 
    682   //   * \param uid Module UID 
    683   //   * \return Module container 
    684   //   */ 
    685   //  public ModuleContainer getModule(String uid) { 
    686   //      ModuleContainer result = modules.get(uid); 
    687   //      if (result == null) { 
    688   //          synchronized (modules) {  // make port container creation thread-safe 
    689   //              result = modules.get(uid); 
    690   //              if (result == null) { 
    691   //                  result = new ModuleContainer(uid); 
    692   //                  modules.put(uid, result); 
    693   //              } 
    694   //          } 
    695   //      } 
    696   //      return result; 
    697   //  } 
    698   // 
    699   //  /** 
    700   //   * Called by modules when they are deleted. 
    701   //   * Detaches them from ModuleContainer 
    702   //   * 
    703   //   * \param port Module to unregister 
    704   //   */ 
    705   //  public void unregisterModule(Module module) { 
    706   //      ModuleContainer mc = getModule(module.getUid()); 
    707   //      if (mc.getModule() == module) { 
    708   //          mc.setModule(null); 
    709   //          activeModuleCount--; 
    710   //      } 
    711   //      reschedule(); 
    712   //  } 
    713  
    714   //  /** 
    715   //   * Set reschedule flags for all loop threads 
    716   //   */ 
    717   //  public void reschedule() { 
    718   //      for (int i = 0; i < loopThreads.size(); i++) { 
    719   //          loopThreads.get(i).setRescheduleFlag(); 
    720   //      } 
    721   //  } 
    722   // 
    723  
    724   /*! 
    725307   * Start executing all Modules and Thread Containers in runtime 
    726308   */ 
  • tRuntimeSettings.cpp

    r28 r57  
    4444    update_time_listener() 
    4545{ 
    46   // add shared ports port 
    47   //addChild(sharedPorts.getPortSet()); 
    48  
    49   // init data type register 
    50   //DataTypeRegister.init(); 
    51  
    5246  // add ports with update times 
    5347  //addChild(DataTypeRegister2.getInstance()); 
  • tRuntimeSettings.h

    r28 r57  
    6767  static tLongSetting* cDEFAULT_CYCLE_TIME; 
    6868 
    69   /*! Maximum number of threads */ 
    70   //public static final IntSetting MAX_THREADS = inst.add("MAX_THREADS", 256, false); // only required during initialization 
    71  
    72   /*! Default number of loop threads */ 
    73   //public static final IntSetting NUM_OF_LOOP_THREADS = inst.add("NUM_OF_LOOP_THREADS", 8, false); 
    74  
    75   /*! Default number of self updating loop threads */ 
    76   //public static final IntSetting SELF_UPDATING_LOOP_THREADS = inst.add("SELF_UPDATING_LOOP_THREADS", 8, false); 
    77  
    7869  /*! Default number of event threads */ 
    7970  //public static final IntSetting NUM_OF_EVENT_THREADS = inst.add("NUM_OF_EVENT_THREADS", 2, false); 
    80  
    81   /*! Maximum queue size for reference queues in ports */ 
    82   //public static final int MAX_PORT_REFERENCE_QUEUE_SIZE = getInt("MAX_PORT_REFERENCE_QUEUE_SIZE", Integer.MAX_VALUE); 
    8371 
    8472  /*! Default minimum network update time (ms) */ 
     
    8977  static const int cEDGE_LIST_SIZE_INCREASE_FACTOR = 2; 
    9078 
    91   /*! Debug Settings */ 
    92   /*public static final BoolSetting DISPLAY_MODULE_UPDATES = inst.add("DISPLAY_MODULE_UPDATES", false, true); 
    93   public static final BoolSetting DISPLAY_MCA_MODULE_UPDATES = inst.add("DISPLAY_MCA_MODULE_UPDATES", false, true); 
    94   public static final BoolSetting DISPLAY_MCA_MESSAGES = inst.add("DISPLAY_MCA_MESSAGES", true, true); 
    95   public static final BoolSetting DISPLAY_MCA_BB_MESSAGES = inst.add("DISPLAY_MCA_BB_MESSAGES", false, true); 
    96   public static final BoolSetting DISPLAY_LOOP_TIME = inst.add("DISPLAY_LOOP_TIME", false, true); 
    97   public static final BoolSetting DISPLAY_DATATYPE_INIT = inst.add("DISPLAY_DATATYPE_INIT", false, true); 
    98   public static final BoolSetting DISPLAY_BUFFER_ALLOCATION = inst.add("DISPLAY_BUFFER_ALLOCATION", false, true); 
    99   public static final BoolSetting DISPLAY_INCOMING_PORT_INFO = inst.add("DISPLAY_INCOMING_PORT_INFO", false, true); 
    100   public static final BoolSetting LOG_LOOP_TIMES = inst.add("LOG_LOOP_TIMES", false, true); 
    101   public static final BoolSetting DISPLAY_CONSOLE = inst.add("DISPLAY_CONSOLE", false, true);*/ 
    102  
    10379  /*! Loop time for buffer tracker (in ms) */ 
    10480  //public static final IntSetting BUFFER_TRACKER_LOOP_TIME = inst.add("BUFFER_TRACKER_LOOP_TIME", 140, true); 
     
    10682  /*! Cycle time for stream thread */ 
    10783  static tIntSetting* cSTREAM_THREAD_CYCLE_TIME; 
    108  
    109   /*! Create tree node for every RuntimeElement class? (needed for tree view as in GUI) */ 
    110   //@JavaOnly public static final BoolSetting CREATE_TREE_NODES_FOR_RUNTIME_ELEMENTS = inst.add("CREATE_TREE_NODES_FOR_RUNTIME_ELEMENTS", false, false); 
    11184 
    11285  /*! > 0 if Runtime is instantiated in Java Applet - contains bit size of server CPU */ 
     
    11891   */ 
    11992  static tIntSetting* cGARBAGE_COLLECTOR_SAFETY_PERIOD; 
    120  
    121   /*! Port with information about shared ports */ 
    122   //SharedPorts sharedPorts; // always has port index zero 
    12393 
    12494  /*! Collect edge statistics ? */ 
     
    140110 
    141111public: 
    142  
    143   //  @Override 
    144   //  protected void update() {} 
    145  
    146   //@Override 
    147   //public synchronized void delete() {} 
    148  
    149   //  /** 
    150   //   * \return Local information list about shared ports 
    151   //   */ 
    152   //  public SharedPorts getSharedPorts() { 
    153   //      return sharedPorts; 
    154   //  } 
    155112 
    156113  /*! 
  • test/tRealPortTest5.h

    r56 r57  
    6767  static void TestSimpleSet(); 
    6868 
    69 // 
    70 // 
    71 //  public static class TestModule extends Module { 
    72 // 
    73 //      DoublePort p1 = new DoublePort("p1", new PortCreationInfo(PortFlags.OUTPUT_PORT)); 
    74 //      DoublePort p2 = new DoublePort("p2", new PortCreationInfo(PortFlags.OUTPUT_PORT)); 
    75 //      //IntPort ip = new IntPort(new PortCreationInfo(PortFlags.INPUT_PORT, "ip")); 
    76 //      DoublePort ip = new DoublePort("ip", new PortCreationInfo(PortFlags.INPUT_PORT)); 
    77 // 
    78 // 
    79 //      public TestModule(CoreEventThread ct) { 
    80 //          super(true); 
    81 //          setDescription("module"); 
    82 //          //setEventThread(ct); 
    83 //          /*p1.setValuesBeforeAreUnused(Long.MAX_VALUE); 
    84 //          p2.setValuesBeforeAreUnused(Long.MAX_VALUE); 
    85 //          ip.setValuesBeforeAreUnused(Long.MAX_VALUE);*/ 
    86 //          addChild(p1); 
    87 //          addChild(p2); 
    88 //          addChild(ip); 
    89 //      } 
    90 // 
    91 //      @Override 
    92 //      protected void update() { 
    93 //      } 
    94 // 
    95 //  } 
    96  
    9769}; 
    9870 
  • thread/tCoreLoopThreadBase.h

    r30 r57  
    6565  } 
    6666 
    67 //  /** currently acquired locks - should be thread safe since only modified by this thread */ 
    68 //  private final FastSet<Lockable> currentLocks = new FastSet<Lockable>(); 
    69 // 
    70 //  /** Index of Thread */ 
    71 //  private final int index; 
    72 // 
    73 //  /** Does thread update critical iteration itself? */ 
    74 //  protected final boolean updatesIterationItself; 
    75 // 
    76 //  /** increases monotonically */ 
    77 //  protected volatile int hasNoValuesBeforeIteration; 
    78 // 
    79 //  public CoreThread(int index, boolean updatesIterationItself, boolean startThread) { 
    80 //      super(RuntimeSettings.DEFAULT_CYCLE_TIME, RuntimeSettings.WARN_ON_CYCLE_TIME_EXCEED, true); 
    81 //      this.index = index; 
    82 //      this.updatesIterationItself = updatesIterationItself; 
    83 //      setName(getClass().getSimpleName() + " " + index); 
    84 //      hasNoValuesBeforeIteration = BufferTracker.getInstance().getCurIteration(); 
    85 //      BufferTracker.getInstance().registerThread(this); 
    86 // 
    87 //      if (startThread) { 
    88 //          start(); 
    89 //      } 
    90 //  } 
    91 // 
    92 //  @Override 
    93 //  public void run() { 
    94 //      super.run(); 
    95 //      cleanShutdown(); 
    96 //  } 
    97 // 
    98 //  public void cleanShutdown() { 
    99 //      BufferTracker.getInstance().unregisterThread(this); 
    100 //  } 
    101 // 
    102 // 
    103 //  @Override 
    104 //  public int locksNoValuesBeforeIteration(int curIteration) { 
    105 //      if (isWaiting()) { 
    106 //          hasNoValuesBeforeIteration = curIteration; 
    107 //          return curIteration; 
    108 //      } 
    109 //      if (updatesIterationItself) { 
    110 //          return hasNoValuesBeforeIteration; 
    111 //      } else { 
    112 //          synchronized(this) { 
    113 //              return curIteration; 
    114 //          } 
    115 //      } 
    116 //  } 
    117 // 
    118 //  /** release all locks */ 
    119 //  public void releaseLocks() { 
    120 //      if (updatesIterationItself) { 
    121 //          int iteration = BufferTracker.getInstance().getCurIteration(); 
    122 //          if (iteration > hasNoValuesBeforeIteration) { 
    123 //              hasNoValuesBeforeIteration = iteration; 
    124 //          } 
    125 //      } 
    126 //      if (currentLocks.size() == 0) { 
    127 //          return; 
    128 //      } 
    129 //      for (FastSet.Record r = currentLocks.head(), end = currentLocks.tail(); (r = r.getNext()) != end;) { 
    130 //          currentLocks.valueOf(r).release(this); 
    131 //      } 
    132 //      currentLocks.clear(); 
    133 //  } 
    134 // 
    135 //  /** 
    136 //   * Add lock 
    137 //   * 
    138 //   * \param l Object that is locked by this thread 
    139 //   */ 
    140 //  public void addLock(Lockable l) { 
    141 //      currentLocks.add(l); 
    142 //  } 
    143 // 
    144 //  /** 
    145 //   * \return Thread Index 
    146 //   */ 
    147 //  public int getIndex() { 
    148 //      return index; 
    149 //  } 
    150 // 
    151 //  public boolean updatesIterationItself() { 
    152 //      return updatesIterationItself; 
    153 //  } 
    154  
    15567}; 
    15668 
Note: See TracChangeset for help on using the changeset viewer.