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}.
class_docstr_tok: ["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","}","."]
code: def make_all(
      self,
      input_storage=None,
      output_storage=None,
      storage_map=None,
  ):
      fgraph: Any = 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 defined !!
          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)
      post_thunk_old_storage: Any = [] if self.allow_gc else 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 = 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__
      f.storage_map = storage_map
  
      return (
          f,
          [
              Container(input, storage)
              for input, storage in zip(fgraph.inputs, input_storage)
          ],
          [
              Container(output, storage, readonly=True)
              for output, storage in zip(fgraph.outputs, output_storage)
          ],
          thunks,
          order,
      )
  
imports: from abc import ABC, abstractmethod
  from collections.abc import Sequence
  from copy import copy, deepcopy
  from typing import TYPE_CHECKING, Any, Callable, Optional, Union
  from pytensor.configdefaults import config
  from pytensor.graph.basic import Apply, Variable
  from pytensor.graph.fg import FunctionGraph
  from pytensor.graph.type import Type
  from pytensor.link.utils import gc_helper, map_storage, raise_with_op, streamline
  from pytensor.utils import difference
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