class_docstr: Basic L{Linker} subclass that calls the perform method on each L{Op} in
  the L{FunctionGraph} in the order given by L{Linker.schedule}.
docstr: Returns Function to run all nodes, list of input containers, list of outputs
  
  Parameters
  ----------
  input_storage
      list of storages corresponding to fgraph.inputs
  output_storage
      list of storages corresponding to fgraph.outputs
  
  Returns
  -------
  object
      Function to run all nodes, list of input containers, list of output
      containers, list of thunks (for all programs), list of nodes
      (for all programs).
docstr_tok: ["Returns","Function","to","run","all","nodes",",","list","of","input","containers",",","list","of","outputs","Parameters","--","--","--","--","--","input_storage","list","of","storages","corresponding","to","fgraph.inputs","output_storage","list","of","storages","corresponding","to","fgraph.outputs","Returns","--","--","--","-","object","Function","to","run","all","nodes",",","list","of","input","containers",",","list","of","output","containers",",","list","of","thunks","(","for","all","programs",")",",","list","of","nodes","(","for","all","programs",")","."]
code: def make_all(
      self, input_storage=None, output_storage=None, storage_map=None
  ):
      """
      Returns Function to run all nodes, list of input containers, list of outputs
  
      Parameters
      ----------
      input_storage
          list of storages corresponding to fgraph.inputs
      output_storage
          list of storages corresponding to fgraph.outputs
  
      Returns
      -------
      object
          Function to run all nodes, list of input containers, list of output
          containers, list of thunks (for all programs), list of nodes
          (for all programs).
  
      """
      fgraph = self.fgraph
      order = self.schedule(fgraph)
      no_recycling = self.no_recycling
  
      input_storage, output_storage, storage_map = map_storage(
          fgraph, order, input_storage, output_storage, storage_map
      )
  
      compute_map = {}
      for k in storage_map:
          compute_map[k] = [k.owner is None]
  
      thunks = []
      for node in order:
          # Maker sure we don't use C version of the code, but rather only
          # the python version
          # Note : ops that implement their own make thunk don't usually
          # have this attribute defiend !!
          thunks += [
              node.op.make_thunk(
                  node, storage_map, compute_map, no_recycling, "py"
              )
          ]
          thunks[-1].inputs = [storage_map[v] for v in node.inputs]
          thunks[-1].outputs = [storage_map[v] for v in node.outputs]
  
      computed, last_user = gc_helper(order)
      if self.allow_gc:
          post_thunk_old_storage = []
      else:
          post_thunk_old_storage = None
  
      for node in order:
          if self.allow_gc:
              post_thunk_old_storage.append(
                  [
                      storage_map[input]
                      for input in node.inputs
                      if (input in computed)
                      and (input not in fgraph.outputs)
                      and (node == last_user[input])
                  ]
              )
  
      if no_recycling is True:
          # True seems like some special code for *everything*?? -JB
          # FunctionMaker always passes a list I think   -JB
          no_recycling = list(storage_map.values())
          no_recycling = utils.difference(no_recycling, input_storage)
      else:
          no_recycling = [
              storage_map[r]
              for r in no_recycling
              if r not in fgraph.inputs
          ]
  
      # The function that actually runs your program is one of the f's in streamline.
      f = streamline(
          fgraph,
          thunks,
          order,
          post_thunk_old_storage,
          no_recycling=no_recycling,
      )
  
      f.allow_gc = (
          self.allow_gc
      )  # HACK: this is a way of passing an arg to Function.__call__
      add_clear_storage(f, computed, storage_map)
      f.storage_map = storage_map
  
      return (
          f,
          [
              Container(input, storage)
              for input, storage in izip(fgraph.inputs, input_storage)
          ],
          [
              Container(output, storage, True)
              for output, storage in izip(
                  fgraph.outputs, output_storage
              )
          ],
          thunks,
          order,
      )
  
imports: from __future__ import absolute_import, print_function, division
  from copy import copy, deepcopy
  from sys import getsizeof
  import sys
  import traceback
  import numpy
  import theano
  from theano.compat import izip
  from six import reraise
  from six.moves import StringIO
  from theano.gof import utils
  from theano.gof import graph
  from theano.gof.type import Type
  from .utils import undef
label_desc: Use image node_id 3 for calling the PerformLinker obj's underlying member method code with example usage: obj.make_all(input_storage, output_storage, storage_map) and returns: f,  unknown,  unknown,  thunks,  order