Remove proc terminology from variable names

Author: pintohutch

nipype/interfaces/tests/test_runtime_profiler.py

@@ -28,7 +28,7 @@ class UseResourcesInputSpec(CommandLineInputSpec):
     # Init attributes
     num_gb = traits.Float(desc='Number of GB of RAM to use',
                           argstr='-g %f')
-    num_procs = traits.Int(desc='Number of processors to use',
+    num_threads = traits.Int(desc='Number of threads to use',
                           argstr='-p %d')
 
 
@@ -52,8 +52,8 @@ class UseResources(CommandLine):
     _cmd = exec_path
 
 
-# Spin multiple processors
-def use_resources(num_procs, num_gb):
+# Spin multiple threads
+def use_resources(num_threads, num_gb):
     '''
     Function to execute multiple use_gb_ram functions in parallel
     '''
@@ -82,19 +82,19 @@ def _use_gb_ram(num_gb):
     # Init variables
     num_gb = float(num_gb)
 
-    # Build proc list
-    proc_list = []
-    for idx in range(num_procs):
-        proc = Thread(target=_use_gb_ram, args=(num_gb/num_procs,), name=str(idx))
-        proc_list.append(proc)
+    # Build thread list
+    thread_list = []
+    for idx in range(num_threads):
+        thread = Thread(target=_use_gb_ram, args=(num_gb/num_threads,), name=str(idx))
+        thread_list.append(thread)
 
     # Run multi-threaded
-    print 'Using %.3f GB of memory over %d sub-threads...' % (num_gb, num_procs)
-    for idx, proc in enumerate(proc_list):
-        proc.start()
+    print 'Using %.3f GB of memory over %d sub-threads...' % (num_gb, num_threads)
+    for idx, thread in enumerate(thread_list):
+        thread.start()
 
-    for proc in proc_list:
-        proc.join()
+    for thread in thread_list:
+        thread.join()
 
 
 # Test case for the run function
@@ -134,9 +134,9 @@ def setUp(self):
         self.mem_err_percent = 5
 
     # ! Only used for benchmarking the profiler over a range of
-    # ! processors and RAM usage
-    # ! Requires a LOT of RAM and PROCS to be tested
-    def _collect_range_runtime_stats(self):
+    # ! RAM usage
+    # ! Requires a LOT of RAM to be tested
+    def _collect_range_runtime_stats(self, num_threads):
         '''
         Function to collect a range of runtime stats
         '''
@@ -147,54 +147,58 @@ def _collect_range_runtime_stats(self):
         import pandas as pd
 
         # Init variables
-        num_procs_range = 8
         ram_gb_range = 10.0
         ram_gb_step = 0.25
         dict_list = []
 
         # Iterate through all combos
-        for num_procs in np.arange(1, num_procs_range+1, 1):
-            for num_gb in np.arange(0.25, ram_gb_range+ram_gb_step, ram_gb_step):
-                # Cmd-level
-                cmd_fin_str = self._run_cmdline_workflow(num_gb, num_procs)
-                cmd_node_stats = json.loads(cmd_fin_str)
-                cmd_runtime_procs = int(cmd_node_stats['runtime_threads'])
-                cmd_runtime_gb = float(cmd_node_stats['runtime_memory_gb'])
-
-                # Func-level
-                func_fin_str = self._run_function_workflow(num_gb, num_procs)
-                func_node_stats = json.loads(func_fin_str)
-                func_runtime_procs = int(func_node_stats['runtime_threads'])
-                func_runtime_gb = float(func_node_stats['runtime_memory_gb'])
-
-                # Calc errors
-                cmd_procs_err = cmd_runtime_procs - num_procs
-                cmd_gb_err = cmd_runtime_gb - num_gb
-                func_procs_err = func_runtime_procs - num_procs
-                func_gb_err = func_runtime_gb - num_gb
-
-                # Node dictionary
-                results_dict = {'input_procs' : num_procs,
-                                'input_gb' : num_gb,
-                                'cmd_runtime_procs' : cmd_runtime_procs,
-                                'cmd_runtime_gb' : cmd_runtime_gb,
-                                'func_runtime_procs' : func_runtime_procs,
-                                'func_runtime_gb' : func_runtime_gb,
-                                'cmd_procs_err' : cmd_procs_err,
-                                'cmd_gb_err' : cmd_gb_err,
-                                'func_procs_err' : func_procs_err,
-                                'func_gb_err' : func_gb_err}
-                # Append to list
-                dict_list.append(results_dict)
+        for num_gb in np.arange(0.25, ram_gb_range+ram_gb_step, ram_gb_step):
+            # Cmd-level
+            cmd_fin_str = self._run_cmdline_workflow(num_gb, num_threads)
+            cmd_node_stats = json.loads(cmd_fin_str)
+            cmd_runtime_threads = int(cmd_node_stats['runtime_threads'])
+            cmd_runtime_gb = float(cmd_node_stats['runtime_memory_gb'])
+
+            # Func-level
+            func_fin_str = self._run_function_workflow(num_gb, num_threads)
+            func_node_stats = json.loads(func_fin_str)
+            func_runtime_threads = int(func_node_stats['runtime_threads'])
+            func_runtime_gb = float(func_node_stats['runtime_memory_gb'])
+
+            # Calc errors
+            cmd_threads_err = cmd_threads_threads - num_threads
+            cmd_gb_err = cmd_runtime_gb - num_gb
+            func_threads_err = func_runtime_threads - num_threads
+            func_gb_err = func_runtime_gb - num_gb
+
+            # Node dictionary
+            results_dict = {'input_threads' : num_threads,
+                            'input_gb' : num_gb,
+                            'cmd_runtime_threads' : cmd_runtime_threads,
+                            'cmd_runtime_gb' : cmd_runtime_gb,
+                            'func_runtime_threads' : func_runtime_threads,
+                            'func_runtime_gb' : func_runtime_gb,
+                            'cmd_thread_err' : cmd_thread_err,
+                            'cmd_gb_err' : cmd_gb_err,
+                            'func_thread_err' : func_thread_err,
+                            'func_gb_err' : func_gb_err}
+            # Append to list
+            dict_list.append(results_dict)
 
         # Create dataframe
         runtime_results_df = pd.DataFrame(dict_list)
 
         # Return dataframe
         return runtime_results_df
 
+    def tiest_collect_range(self):
+        num_threads = 1
+        df = self._collect_range_suntime_stats(num_threads)
+
+        df.to_csv('/root/%d_thread_df.csv')
+
     # Test node
-    def _run_cmdline_workflow(self, num_gb, num_procs):
+    def _run_cmdline_workflow(self, num_gb, num_threads):
         '''
         Function to run the use_resources cmdline script in a nipype workflow
         and return the runtime stats recorded by the profiler
@@ -237,22 +241,22 @@ def _run_cmdline_workflow(self, num_gb, num_procs):
 
         # Input node
         input_node = pe.Node(util.IdentityInterface(fields=['num_gb',
-                                                            'num_procs']),
+                                                            'num_threads']),
                              name='input_node')
         input_node.inputs.num_gb = num_gb
-        input_node.inputs.num_procs = num_procs
+        input_node.inputs.num_threads = num_threads
 
         # Resources used node
         resource_node = pe.Node(UseResources(), name='resource_node')
         resource_node.interface.estimated_memory_gb = num_gb
-        resource_node.interface.num_threads = num_procs
+        resource_node.interface.num_threads = num_threads
 
         # Connect workflow
         wf.connect(input_node, 'num_gb', resource_node, 'num_gb')
-        wf.connect(input_node, 'num_procs', resource_node, 'num_procs')
+        wf.connect(input_node, 'num_threads', resource_node, 'num_threads')
 
         # Run workflow
-        plugin_args = {'n_procs' : num_procs,
+        plugin_args = {'n_procs' : num_threads,
                        'memory' : num_gb,
                        'status_callback' : log_nodes_cb}
         wf.run(plugin='MultiProc', plugin_args=plugin_args)
@@ -267,7 +271,7 @@ def _run_cmdline_workflow(self, num_gb, num_procs):
         return finish_str
 
     # Test node
-    def _run_function_workflow(self, num_gb, num_procs):
+    def _run_function_workflow(self, num_gb, num_threads):
         '''
         Function to run the use_resources() function in a nipype workflow
         and return the runtime stats recorded by the profiler
@@ -310,26 +314,26 @@ def _run_function_workflow(self, num_gb, num_procs):
 
         # Input node
         input_node = pe.Node(util.IdentityInterface(fields=['num_gb',
-                                                            'num_procs']),
+                                                            'num_threads']),
                              name='input_node')
         input_node.inputs.num_gb = num_gb
-        input_node.inputs.num_procs = num_procs
+        input_node.inputs.num_threads = num_threads
 
         # Resources used node
-        resource_node = pe.Node(util.Function(input_names=['num_procs',
+        resource_node = pe.Node(util.Function(input_names=['num_threads',
                                                            'num_gb'],
                                               output_names=[],
                                               function=use_resources),
                                 name='resource_node')
         resource_node.interface.estimated_memory_gb = num_gb
-        resource_node.interface.num_threads = num_procs
+        resource_node.interface.num_threads = num_threads
 
         # Connect workflow
         wf.connect(input_node, 'num_gb', resource_node, 'num_gb')
-        wf.connect(input_node, 'num_procs', resource_node, 'num_procs')
+        wf.connect(input_node, 'num_threads', resource_node, 'num_threads')
 
         # Run workflow
-        plugin_args = {'n_procs' : num_procs,
+        plugin_args = {'n_procs' : num_threads,
                        'memory' : num_gb,
                        'status_callback' : log_nodes_cb}
         wf.run(plugin='MultiProc', plugin_args=plugin_args)
@@ -378,12 +382,12 @@ def test_cmdline_profiling(self):
         # Error message formatting
         mem_err = 'Input memory: %f is not within %.1f%% of runtime '\
                   'memory: %f' % (num_gb, self.mem_err_percent, runtime_gb)
-        procs_err = 'Input threads: %d is not equal to runtime threads: %d' \
+        threads_err = 'Input threads: %d is not equal to runtime threads: %d' \
                     % (expected_runtime_threads, runtime_threads)
 
         # Assert runtime stats are what was input
         self.assertLessEqual(runtime_gb_err, allowed_gb_err, msg=mem_err)
-        self.assertEqual(expected_runtime_threads, runtime_threads, msg=procs_err)
+        self.assertEqual(expected_runtime_threads, runtime_threads, msg=threads_err)
 
     # Test resources were used as expected
     @unittest.skipIf(run_profiler == False, skip_profile_msg)
@@ -420,12 +424,12 @@ def test_function_profiling(self):
         # Error message formatting
         mem_err = 'Input memory: %f is not within %.1f%% of runtime '\
                   'memory: %f' % (num_gb, self.mem_err_percent, runtime_gb)
-        procs_err = 'Input procs: %d is not equal to runtime procs: %d' \
+        threads_err = 'Input threads: %d is not equal to runtime threads: %d' \
                     % (expected_runtime_threads, runtime_threads)
 
         # Assert runtime stats are what was input
         self.assertLessEqual(runtime_gb_err, allowed_gb_err, msg=mem_err)
-        self.assertEqual(expected_runtime_threads, runtime_threads, msg=procs_err)
+        self.assertEqual(expected_runtime_threads, runtime_threads, msg=threads_err)
 
 
 # Command-line run-able unittest module

nipype/interfaces/tests/use_resources

@@ -4,10 +4,10 @@
 
 '''
 Python script to use a certain amount of RAM on disk and number of
-processors
+threads
 
 Usage:
-    use_resources -g <num_gb> -p <num_procs>
+    use_resources -g <num_gb> -p <num_threads>
 '''
 
 # Function to occupy GB of memory
@@ -42,25 +42,25 @@ if __name__ == '__main__':
     # Add arguments
     parser.add_argument('-g', '--num_gb', nargs=1, required=True,
                         help='Number of GB RAM to use, can be float or int')
-    parser.add_argument('-p', '--num_procs', nargs=1, required=True,
-                        help='Number of processors to run in parallel')
+    parser.add_argument('-p', '--num_threads', nargs=1, required=True,
+                        help='Number of threads to run in parallel')
 
     # Parse args
     args = parser.parse_args()
 
     # Init variables
     num_gb = float(args.num_gb[0])
-    num_procs = int(args.num_procs[0])
+    num_threads = int(args.num_threads[0])
 
-    # Build proc list
-    proc_list = []
-    for idx in range(num_procs):
-        proc_list.append(Thread(target=use_gb_ram, args=(num_gb/num_procs,)))
+    # Build thread list
+    thread_list = []
+    for idx in range(num_threads):
+        thread_list.append(Thread(target=use_gb_ram, args=(num_gb/num_threads,)))
 
     # Run multi-threaded
-    print 'Using %.3f GB of memory over %d sub-threads...' % (num_gb, num_procs)
-    for proc in proc_list:
-        proc.start()
+    print 'Using %.3f GB of memory over %d sub-threads...' % (num_gb, num_threads)
+    for thread in thread_list:
+        thread.start()
 
-    for proc in proc_list:
-        proc.join()
+    for thread in thread_list:
+        thread.join()