Moving unique_name to python

* Add reset and guard to unique_name

Author: reyoung

paddle/fluid/pybind/pybind.cc

@@ -48,11 +48,6 @@ PYBIND11_MAKE_OPAQUE(paddle::framework::LoDTensorArray);
 
 namespace paddle {
 namespace pybind {
-static size_t UniqueIntegerGenerator(const std::string &prefix) {
-  static std::unordered_map<std::string, std::atomic<size_t>> generators;
-  return generators[prefix].fetch_add(1);
-}
-
 bool IsCompiledWithCUDA() {
 #ifndef PADDLE_WITH_CUDA
   return false;
@@ -409,7 +404,6 @@ All parameter, weight, gradient are variables in Paddle.
            (void (Executor::*)(const ProgramDesc &, Scope *, int, bool, bool)) &
                Executor::Run);
 
-  m.def("unique_integer", UniqueIntegerGenerator);
   m.def("init_gflags", framework::InitGflags);
   m.def("init_glog", framework::InitGLOG);
   m.def("init_devices", &framework::InitDevices);

python/paddle/v2/fluid/__init__.py

@@ -39,30 +39,16 @@
 import clip
 from memory_optimization_transpiler import memory_optimize
 import profiler
+import unique_name
 
 Tensor = LoDTensor
 
 __all__ = framework.__all__ + executor.__all__ + concurrency.__all__ + [
-    'io',
-    'initializer',
-    'layers',
-    'nets',
-    'optimizer',
-    'learning_rate_decay',
-    'backward',
-    'regularizer',
-    'LoDTensor',
-    'CPUPlace',
-    'CUDAPlace',
-    'Tensor',
-    'ParamAttr',
-    'WeightNormParamAttr',
-    'DataFeeder',
-    'clip',
-    'SimpleDistributeTranspiler',
-    'DistributeTranspiler',
-    'memory_optimize',
-    'profiler',
+    'io', 'initializer', 'layers', 'nets', 'optimizer', 'learning_rate_decay',
+    'backward', 'regularizer', 'LoDTensor', 'CPUPlace', 'CUDAPlace', 'Tensor',
+    'ParamAttr', 'WeightNormParamAttr', 'DataFeeder', 'clip',
+    'SimpleDistributeTranspiler', 'DistributeTranspiler', 'memory_optimize',
+    'profiler', 'unique_name'
 ]
 
 

python/paddle/v2/fluid/backward.py

@@ -16,6 +16,7 @@
 from . import core
 import collections
 import copy
+import unique_name
 
 __all__ = [
     'append_backward',
@@ -388,7 +389,7 @@ def _rename_grad_(block, start_op_idx, grad_to_var, target_grad_map):
 
         for name in op_desc.output_arg_names():
             if block.desc.find_var(name.encode("ascii")):
-                new_name = "%s_%s" % (name, core.unique_integer(name))
+                new_name = unique_name.generate(name)
                 op_desc.rename_output(name, new_name)
                 var_map[name] = new_name
 

python/paddle/v2/fluid/evaluator.py

@@ -15,7 +15,8 @@
 import numpy as np
 
 import layers
-from framework import Program, unique_name, Variable, program_guard
+from framework import Program, Variable, program_guard
+import unique_name
 from layer_helper import LayerHelper
 
 __all__ = [
@@ -96,7 +97,7 @@ def create_state(self, suffix, dtype, shape):
 
         """
         state = self.helper.create_variable(
-            name="_".join([unique_name(self.helper.name), suffix]),
+            name="_".join([unique_name.generate(self.helper.name), suffix]),
             persistable=True,
             dtype=dtype,
             shape=shape)

python/paddle/v2/fluid/framework.py

@@ -20,6 +20,7 @@
 
 import proto.framework_pb2 as framework_pb2
 from . import core
+import unique_name
 
 __all__ = [
     'Block',
@@ -47,20 +48,6 @@ def grad_var_name(var_name):
     return var_name + GRAD_VAR_SUFFIX
 
 
-def unique_name(prefix):
-    """
-    Generate unique names with prefix
-
-    Args:
-        prefix(str): The prefix of return string
-
-    Returns(str): A unique string with the prefix
-
-    """
-    uid = core.unique_integer(prefix)  # unique during whole process.
-    return "_".join([prefix, str(uid)])
-
-
 def convert_np_dtype_to_dtype_(np_dtype):
     """
     Convert the data type in numpy to the data type in Paddle
@@ -175,7 +162,7 @@ def __init__(self,
         self.error_clip = error_clip
 
         if name is None:
-            name = Variable._unique_var_name_()
+            name = unique_name.generate('_generated_var')
         is_new_var = False
         self.desc = self.block.desc.find_var(name)
 
@@ -303,12 +290,6 @@ def lod_level(self):
     def type(self):
         return self.desc.type()
 
-    @staticmethod
-    def _unique_var_name_():
-        prefix = "_generated_var"
-        uid = core.unique_integer(prefix)  # unique during whole process.
-        return "_".join([prefix, str(uid)])
-
     def set_error_clip(self, error_clip):
         self.error_clip = error_clip
 

python/paddle/v2/fluid/layer_helper.py

@@ -15,8 +15,8 @@
 import copy
 import itertools
 
-from framework import Variable, Parameter, default_main_program, default_startup_program, \
-    unique_name, dtype_is_floating
+from framework import Variable, Parameter, default_main_program, default_startup_program, dtype_is_floating
+import unique_name
 from paddle.v2.fluid.initializer import Constant, Xavier
 from param_attr import ParamAttr, WeightNormParamAttr
 
@@ -27,7 +27,7 @@ def __init__(self, layer_type, **kwargs):
         self.layer_type = layer_type
         name = self.kwargs.get('name', None)
         if name is None:
-            self.kwargs['name'] = unique_name(self.layer_type)
+            self.kwargs['name'] = unique_name.generate(self.layer_type)
 
     @property
     def name(self):
@@ -117,17 +117,20 @@ def __norm_op(x,
                       block=self.startup_program.global_block()):
             if out is None:
                 out = block.create_var(
-                    name=unique_name(".".join([self.name, 'weight_norm_norm'])),
+                    name=unique_name.generate(".".join(
+                        [self.name, 'weight_norm_norm'])),
                     dtype=dtype,
                     persistable=False)
             abs_out = block.create_var(
-                name=unique_name(".".join([self.name, 'weight_norm_abs'])),
+                name=unique_name.generate(".".join(
+                    [self.name, 'weight_norm_abs'])),
                 dtype=dtype,
                 persistable=False)
             block.append_op(
                 type='abs', inputs={'X': x}, outputs={'Out': abs_out})
             pow_out = block.create_var(
-                name=unique_name(".".join([self.name, 'weight_norm_pow'])),
+                name=unique_name.generate(".".join(
+                    [self.name, 'weight_norm_pow'])),
                 dtype=dtype,
                 persistable=False)
             block.append_op(
@@ -136,7 +139,8 @@ def __norm_op(x,
                 outputs={'Out': pow_out},
                 attrs={'factor': float(p)})
             sum_out = block.create_var(
-                name=unique_name(".".join([self.name, 'weight_norm_sum'])),
+                name=unique_name.generate(".".join(
+                    [self.name, 'weight_norm_sum'])),
                 dtype=dtype,
                 persistable=False)
             block.append_op(
@@ -161,7 +165,7 @@ def __reshape_op(x,
                          block=self.startup_program.global_block()):
             if out is None:
                 out = block.create_var(
-                    name=unique_name(".".join(
+                    name=unique_name.generate(".".join(
                         [self.name, 'weight_norm_reshape'])),
                     dtype=dtype,
                     persistable=False)
@@ -178,7 +182,7 @@ def __transpose_op(x,
                            block=self.startup_program.global_block()):
             if out is None:
                 out = block.create_var(
-                    name=unique_name(".".join(
+                    name=unique_name.generate(".".join(
                         [self.name, 'weight_norm_transpose'])),
                     dtype=dtype,
                     persistable=False)
@@ -196,7 +200,8 @@ def __norm_except_dim(x,
             """Computes the norm over all dimensions except dim"""
             if out is None:
                 out = block.create_var(
-                    name=unique_name(".".join([self.name, 'weight_norm_norm'])),
+                    name=unique_name.generate(".".join(
+                        [self.name, 'weight_norm_norm'])),
                     dtype=dtype,
                     persistable=False)
             if dim is None:
@@ -286,7 +291,7 @@ def create_parameter(self,
         assert isinstance(attr, ParamAttr)
         suffix = 'b' if is_bias else 'w'
         if attr.name is None:
-            attr.name = unique_name(".".join([self.name, suffix]))
+            attr.name = unique_name.generate(".".join([self.name, suffix]))
 
         if default_initializer is None and attr.initializer is None:
             if is_bias:
@@ -316,7 +321,7 @@ def get_parameter(self, name):
 
     def create_tmp_variable(self, dtype, stop_gradient=False):
         return self.main_program.current_block().create_var(
-            name=unique_name(".".join([self.name, 'tmp'])),
+            name=unique_name.generate(".".join([self.name, 'tmp'])),
             dtype=dtype,
             persistable=False,
             stop_gradient=stop_gradient)

python/paddle/v2/fluid/layers/control_flow.py

@@ -428,7 +428,8 @@ def memory(self,
                 raise ValueError(
                     "if init is None, memory at least need shape and batch_ref")
             parent_block = self.parent_block()
-            var_name = unique_name("@".join([self.helper.name, "memory_boot"]))
+            var_name = unique_name.generate("@".join(
+                [self.helper.name, "memory_boot"]))
             boot_var = parent_block.create_var(
                 name=var_name,
                 shape=shape,
@@ -450,7 +451,7 @@ def memory(self,
             return self.memory(init=boot_var)
         else:
             pre_mem = self.helper.create_variable(
-                name=unique_name("@".join([self.helper.name, "mem"])),
+                name=unique_name.generate("@".join([self.helper.name, "mem"])),
                 dtype=init.dtype,
                 shape=init.shape)
             self.memories[pre_mem.name] = StaticRNNMemoryLink(
@@ -709,7 +710,7 @@ def lod_rank_table(x, level=0):
     helper = LayerHelper("lod_rank_table", **locals())
     table = helper.create_variable(
         type=core.VarDesc.VarType.LOD_RANK_TABLE,
-        name=unique_name("lod_rank_table"))
+        name=unique_name.generate("lod_rank_table"))
     helper.append_op(
         type='lod_rank_table',
         inputs={'X': x},
@@ -807,7 +808,7 @@ def lod_tensor_to_array(x, table):
     """
     helper = LayerHelper("lod_tensor_to_array", **locals())
     array = helper.create_variable(
-        name=unique_name("lod_tensor_to_array"),
+        name=unique_name.generate("lod_tensor_to_array"),
         type=core.VarDesc.VarType.LOD_TENSOR_ARRAY,
         dtype=x.dtype)
     helper.append_op(
@@ -1264,11 +1265,11 @@ def input(self, x):
         if id(x) not in self.input_table:
             parent_block = self.parent_block()
             out_true = parent_block.create_var(
-                name=unique_name('ifelse_input' + self.helper.name),
+                name=unique_name.generate('ifelse_input' + self.helper.name),
                 dtype=x.dtype)
 
             out_false = parent_block.create_var(
-                name=unique_name('ifelse_input' + self.helper.name),
+                name=unique_name.generate('ifelse_input' + self.helper.name),
                 dtype=x.dtype)
             parent_block.append_op(
                 type='split_lod_tensor',
@@ -1310,7 +1311,8 @@ def output(self, *outs):
                 raise TypeError("Each output should be a variable")
             # create outside tensor
             outside_out = parent_block.create_var(
-                name=unique_name("_".join([self.helper.name, 'output'])),
+                name=unique_name.generate("_".join(
+                    [self.helper.name, 'output'])),
                 dtype=each_out.dtype)
             out_table.append(outside_out)
 
@@ -1373,15 +1375,16 @@ def step_input(self, x):
         parent_block = self._parent_block_()
         if self.lod_rank_table is None:
             self.lod_rank_table = parent_block.create_var(
-                name=unique_name('lod_rank_table'),
+                name=unique_name.generate('lod_rank_table'),
                 type=core.VarDesc.VarType.LOD_RANK_TABLE)
             self.lod_rank_table.stop_gradient = True
             parent_block.append_op(
                 type='lod_rank_table',
                 inputs={"X": x},
                 outputs={"Out": self.lod_rank_table})
             self.max_seq_len = parent_block.create_var(
-                name=unique_name('dynamic_rnn_max_seq_len'), dtype='int64')
+                name=unique_name.generate('dynamic_rnn_max_seq_len'),
+                dtype='int64')
             self.max_seq_len.stop_gradient = False
             parent_block.append_op(
                 type='max_sequence_len',
@@ -1395,7 +1398,7 @@ def step_input(self, x):
                 outputs={'Out': self.cond})
 
         input_array = parent_block.create_var(
-            name=unique_name('dynamic_rnn_input_array'),
+            name=unique_name.generate('dynamic_rnn_input_array'),
             type=core.VarDesc.VarType.LOD_TENSOR_ARRAY,
             dtype=x.dtype)
         self.input_array.append((input_array, x.dtype))
@@ -1416,7 +1419,7 @@ def static_input(self, x):
                 "static_input() must be called after step_input().")
         parent_block = self._parent_block_()
         x_reordered = parent_block.create_var(
-            name=unique_name("dynamic_rnn_static_input_reordered"),
+            name=unique_name.generate("dynamic_rnn_static_input_reordered"),
             type=core.VarDesc.VarType.LOD_TENSOR,
             dtype=x.dtype)
         parent_block.append_op(
@@ -1478,7 +1481,7 @@ def memory(self,
                         'invoked before '
                         'memory(init=init, need_reordered=True, ...).')
                 init_reordered = parent_block.create_var(
-                    name=unique_name('dynamic_rnn_mem_init_reordered'),
+                    name=unique_name.generate('dynamic_rnn_mem_init_reordered'),
                     type=core.VarDesc.VarType.LOD_TENSOR,
                     dtype=init.dtype)
                 parent_block.append_op(
@@ -1490,7 +1493,7 @@ def memory(self,
                     outputs={'Out': [init_reordered]})
                 init_tensor = init_reordered
             mem_array = parent_block.create_var(
-                name=unique_name('dynamic_rnn_mem_array'),
+                name=unique_name.generate('dynamic_rnn_mem_array'),
                 type=core.VarDesc.VarType.LOD_TENSOR_ARRAY,
                 dtype=init.dtype)
             parent_block.append_op(
@@ -1510,9 +1513,10 @@ def memory(self,
                 )
             parent_block = self._parent_block_()
             init = parent_block.create_var(
-                name=unique_name('mem_init'), dtype=dtype)
+                name=unique_name.generate('mem_init'), dtype=dtype)
             arr, dtype = self.input_array[0]
-            in0 = parent_block.create_var(name=unique_name('in0'), dtype=dtype)
+            in0 = parent_block.create_var(
+                name=unique_name.generate('in0'), dtype=dtype)
             parent_block.append_op(
                 type='read_from_array',
                 inputs={'X': [arr],
@@ -1551,7 +1555,7 @@ def output(self, *outputs):
         parent_block = self._parent_block_()
         for each in outputs:
             outside_array = parent_block.create_var(
-                name=unique_name("_".join(
+                name=unique_name.generate("_".join(
                     [self.helper.name, "output_array", each.name])),
                 type=core.VarDesc.VarType.LOD_TENSOR_ARRAY,
                 dtype=each.dtype)

python/paddle/v2/fluid/layers/device.py

@@ -25,7 +25,8 @@
 @autodoc()
 def get_places(device_count=None, device_type=None):
     helper = LayerHelper('get_places', **locals())
-    out_places = helper.create_variable(name=unique_name(helper.name + ".out"))
+    out_places = helper.create_variable(
+        name=unique_name.generate(helper.name + ".out"))
     attrs = dict()
     if device_count is not None:
         attrs['device_count'] = int(device_count)