ComputationAnalysis Class Reference

This class performs various kinds of specific analysis on top of what class Analyzer gives you immediately. More...

#include <nnet-analyze.h>

Collaboration diagram for ComputationAnalysis:

Public Member Functions
	ComputationAnalysis (const NnetComputation &computation, const Analyzer &analyzer)
	This class stores the const references provided to its constructor -> be careful about changing them or deallocating them during the lifetime of this object. More...
int32	FirstNontrivialAccess (int32 s) const
	Returns the first command (read or write) that accesses any part of 's' except for zeroing it (i.e. More...
int32	FirstAccess (int32 s) const
	Returns the first command (read or write) that accesses any part of 's', including possibly zeroing it. More...
int32	LastAccess (int32 s) const
	Returns the last non-deallocation command that accesses any part of submatrix 's'; if there is no such command it returns -1. More...
int32	LastWriteAccess (int32 s) const
	Returns the last command-index that accesses any part of submatrix 's' as a write operation, or -1 if there is no such operation. More...
int32	DataInvalidatedCommand (int32 c, int32 s) const
	Returns (the first command-index after 'c' that any part of submatrix 's' is written to); or if there is no such command, then (the command-index of the command that deallocates the matrix underlying s); or if there is no such command, then the total number of commands. More...
int32	FirstNontrivialMatrixAccess (int32 m) const
	Returns the first command that is not a zeroing command (kSetConst with alpha=0.0), that accesses any part of 'm' [note: allocation and deallocation do not count a matrix accesses. More...
int32	LastMatrixAccess (int32 m) const
	Returns the last non-deallocation command that accesses any part of matrix 'm'; if there is no such command it returns -1. More...

Private Attributes
const NnetComputation &	computation_
const Analyzer &	analyzer_

Detailed Description

This class performs various kinds of specific analysis on top of what class Analyzer gives you immediately.

It mostly contains special-purpose things what were needed by class VariableMergingOptimizer (see nnet-optimize.h, and the extended comment above class VariableMergingOptimizer). Be careful about the meaninhg of 'access'- read the comments carefully.

Definition at line 308 of file nnet-analyze.h.

Constructor & Destructor Documentation

ComputationAnalysis()

ComputationAnalysis ( const NnetComputation &  computation, const Analyzer &  analyzer  )

inline

This class stores the const references provided to its constructor -> be careful about changing them or deallocating them during the lifetime of this object.

Definition at line 313 of file nnet-analyze.h.

                                               : computation_(computation),
                                                 analyzer_(analyzer) { }

Member Function Documentation

DataInvalidatedCommand()

int32 DataInvalidatedCommand	(	int32	c,
		int32	s
	)		const

Returns (the first command-index after 'c' that any part of submatrix 's' is written to); or if there is no such command, then (the command-index of the command that deallocates the matrix underlying s); or if there is no such command, then the total number of commands.

s must be >0 (i.e. not the empty submatrix).

Definition at line 1323 of file nnet-analyze.cc.

References NnetComputation::commands, ComputationChecker::computation_, KALDI_ASSERT, kaldi::nnet3::kReadAccess, and NnetComputation::submatrices.

Referenced by VariableMergingOptimizer::MayBeMerged(), and kaldi::nnet3::UnitTestNnetAnalyze().

                                                                        {
  KALDI_ASSERT(static_cast<size_t>(c) < computation_.commands.size());
  KALDI_ASSERT(static_cast<size_t>(s) < computation_.submatrices.size() && s>0);
  int32 matrix_index = computation_.submatrices[s].matrix_index;
  int32 ans = analyzer_.matrix_accesses[matrix_index].deallocate_command;
  if (ans == -1)
    ans = static_cast<int32>(computation_.commands.size());
  std::vector<int32> variable_indexes;
  analyzer_.variables.AppendVariablesForSubmatrix(s, &variable_indexes);
  std::vector<int32>::const_iterator iter = variable_indexes.begin(),
          end = variable_indexes.end();
  for (; iter != end; ++iter) {
    int32 v = *iter;
    const std::vector<Access> &accesses = analyzer_.variable_accesses[v];
    std::vector<Access>::const_iterator access_iter = accesses.begin(),
        access_end = accesses.end();
    for (; access_iter != access_end; ++access_iter) {
      int32 command_index = access_iter->command_index;
      if (command_index > c &&
          access_iter->access_type != kReadAccess) {
        ans = std::min(ans, command_index);
      }
    }
  }
  return ans;
}

FirstAccess()

int32 FirstAccess

(

int32

s

)

const

Returns the first command (read or write) that accesses any part of 's', including possibly zeroing it.

[note: kAllocMatrix, kSwapMatrix and kDeallocMatrix do not count as read or write operations]. If there is no such command, it returns num_commands. s must be >0 (i.e. not the empty submatrix).

Definition at line 1209 of file nnet-analyze.cc.

References NnetComputation::commands, ComputationChecker::computation_, KALDI_ASSERT, and NnetComputation::submatrices.

                                                    {
  KALDI_ASSERT(static_cast<size_t>(s) < computation_.submatrices.size() && s>0);
  int32 ans = computation_.commands.size();
  std::vector<int32> variable_indexes;
  analyzer_.variables.AppendVariablesForSubmatrix(s, &variable_indexes);
  std::vector<int32>::const_iterator iter = variable_indexes.begin(),
          end = variable_indexes.end();
  for (; iter != end; ++iter) {
    int32 v = *iter;
    const std::vector<Access> &accesses = analyzer_.variable_accesses[v];
    if (!accesses.empty())
      ans = std::min(ans, accesses[0].command_index);
  }
  return ans;
}

FirstNontrivialAccess()

int32 FirstNontrivialAccess

(

int32

s

)

const

Returns the first command (read or write) that accesses any part of 's' except for zeroing it (i.e.

kSetConst with zero alpha). [note: kAllocMatrix, kSwapMatrix and kDeallocMatrix do not count as read or write operations]. If there is no such command, it returns num_commands. s must be >0 (i.e. not the empty submatrix).

Definition at line 1182 of file nnet-analyze.cc.

References NnetComputation::Command::alpha, NnetComputation::Command::command_type, NnetComputation::commands, ComputationChecker::computation_, KALDI_ASSERT, kaldi::nnet3::kSetConst, and NnetComputation::submatrices.

Referenced by kaldi::nnet3::ConvertAdditionToAssignment(), ComputationLoopedOptimizer::FindActiveMatrices(), VariableMergingOptimizer::MayBeMerged(), and kaldi::nnet3::UnitTestNnetAnalyze().

                                                              {
  KALDI_ASSERT(static_cast<size_t>(s) < computation_.submatrices.size() && s>0);
  int32 ans = computation_.commands.size();
  std::vector<int32> variable_indexes;
  analyzer_.variables.AppendVariablesForSubmatrix(s, &variable_indexes);
  std::vector<int32>::const_iterator iter = variable_indexes.begin(),
          end = variable_indexes.end();
  for (; iter != end; ++iter) {
    int32 v = *iter;
    const std::vector<Access> &accesses = analyzer_.variable_accesses[v];
    std::vector<Access>::const_iterator access_iter = accesses.begin(),
        access_end = accesses.end();
    for (; access_iter != access_end; ++access_iter) {
      int32 command_index = access_iter->command_index;
      const NnetComputation::Command &command = computation_.commands[
          command_index];
      if (!(command.command_type == kSetConst &&
            command.alpha == 0.0)) {  // if it's not a zeroing command..
        ans = std::min(ans, command_index);
        break;  // break from access_iter loop (an optimization)
      }
    }
  }
  return ans;
}

FirstNontrivialMatrixAccess()

int32 FirstNontrivialMatrixAccess

(

int32

m

)

const

Returns the first command that is not a zeroing command (kSetConst with alpha=0.0), that accesses any part of 'm' [note: allocation and deallocation do not count a matrix accesses.

] If there is no such command, it returns num_commands. m must be >0 (i.e. not the empty matrix).

Definition at line 1226 of file nnet-analyze.cc.

References NnetComputation::Command::alpha, NnetComputation::Command::command_type, NnetComputation::commands, ComputationChecker::computation_, KALDI_ASSERT, kaldi::nnet3::kSetConst, and NnetComputation::matrices.

Referenced by VariableMergingOptimizer::DoMerge().

                                                                    {
  KALDI_ASSERT(static_cast<size_t>(m) < computation_.matrices.size() && m > 0);
  int32 ans = computation_.commands.size();
  const std::vector<Access> &accesses =
      analyzer_.matrix_accesses[m].accesses;
  std::vector<Access>::const_iterator access_iter = accesses.begin(),
      access_end = accesses.end();
  for (; access_iter != access_end; ++access_iter) {
    int32 command_index = access_iter->command_index;
    const NnetComputation::Command command =
        computation_.commands[command_index];
    if (!(command.command_type == kSetConst &&
          command.alpha == 0.0)) {  // except for zeroing commands..
      ans = std::min(ans, command_index);
      break;  // break from access_iter loop (an optimization; note, the
              // list 'accesses' is sorted.)
    }
  }
  return ans;
}

LastAccess()

int32 LastAccess

(

int32

s

)

const

Returns the last non-deallocation command that accesses any part of submatrix 's'; if there is no such command it returns -1.

s must be >0 (i.e. not the empty submatrix).

Definition at line 1264 of file nnet-analyze.cc.

References NnetComputation::commands, ComputationChecker::computation_, KALDI_ASSERT, kaldi::nnet3::kDeallocMatrix, and NnetComputation::submatrices.

Referenced by ComputationLoopedOptimizer::FindActiveMatrices(), VariableMergingOptimizer::MayBeMerged(), and kaldi::nnet3::UnitTestNnetAnalyze().

                                                   {
  KALDI_ASSERT(static_cast<size_t>(s) < computation_.submatrices.size() && s>0);
  int32 ans = -1;
  std::vector<int32> variable_indexes;
  analyzer_.variables.AppendVariablesForSubmatrix(s, &variable_indexes);
  std::vector<int32>::const_iterator iter = variable_indexes.begin(),
      end = variable_indexes.end();
  for (; iter != end; ++iter) {
    int32 v = *iter;
    const std::vector<Access> &accesses = analyzer_.variable_accesses[v];
    // Go through the variable accesses in reverse order (of command index)
    std::vector<Access>::const_reverse_iterator access_iter = accesses.rbegin(),
        access_end = accesses.rend();
    for (; access_iter != access_end; ++access_iter) {
      int32 command_index = access_iter->command_index;
      CommandType command_type =
          computation_.commands[command_index].command_type;
      // deallocation command should not be listed here.
      KALDI_ASSERT(command_type != kDeallocMatrix);
      ans = std::max(ans, command_index);
      break;  // break from access_iter loop (an optimization)
    }
  }
  return ans;
}

LastMatrixAccess()

int32 LastMatrixAccess

(

int32

m

)

const

Returns the last non-deallocation command that accesses any part of matrix 'm'; if there is no such command it returns -1.

m must be >0 (i.e. not the empty matrix).

Definition at line 1248 of file nnet-analyze.cc.

References ComputationChecker::computation_, KALDI_ASSERT, and NnetComputation::matrices.

                                                         {
  KALDI_ASSERT(static_cast<size_t>(m) < computation_.matrices.size() && m > 0);
  int32 ans = -1;
  const std::vector<Access> &accesses =
      analyzer_.matrix_accesses[m].accesses;
  std::vector<Access>::const_reverse_iterator access_iter = accesses.rbegin(),
      access_end = accesses.rend();
  for (; access_iter != access_end; ++access_iter) {
    int32 command_index = access_iter->command_index;
    ans = std::max(ans, command_index);
    break;  // break from access_iter loop (an optimization)
  }
  return ans;
}

LastWriteAccess()

int32 LastWriteAccess

(

int32

s

)

const

Returns the last command-index that accesses any part of submatrix 's' as a write operation, or -1 if there is no such operation.

Note: deallocation does not count as a write operation. s must be >0 (i.e. not the empty submatrix).

Definition at line 1291 of file nnet-analyze.cc.

References NnetComputation::commands, ComputationChecker::computation_, KALDI_ASSERT, kaldi::nnet3::kDeallocMatrix, kaldi::nnet3::kReadAccess, and NnetComputation::submatrices.

Referenced by VariableMergingOptimizer::MayBeMerged(), and kaldi::nnet3::UnitTestNnetAnalyze().

                                                        {
  KALDI_ASSERT(static_cast<size_t>(s) < computation_.submatrices.size() && s>0);
  int32 matrix_index = computation_.submatrices[s].matrix_index;
  if (analyzer_.matrix_accesses[matrix_index].is_output)
    return computation_.commands.size();
  int32 ans = -1;
  std::vector<int32> variable_indexes;
  analyzer_.variables.AppendVariablesForSubmatrix(s, &variable_indexes);
  std::vector<int32>::const_iterator iter = variable_indexes.begin(),
      end = variable_indexes.end();
  for (; iter != end; ++iter) {
    int32 v = *iter;
    const std::vector<Access> &accesses = analyzer_.variable_accesses[v];
    // Go through the variable accesses in reverse order (of command index)
    std::vector<Access>::const_reverse_iterator access_iter = accesses.rbegin(),
        access_end = accesses.rend();
    for (; access_iter != access_end; ++access_iter) {
      int32 command_index = access_iter->command_index;
      CommandType command_type =
          computation_.commands[command_index].command_type;
      // deallocation command should not be listed here.
      KALDI_ASSERT(command_type != kDeallocMatrix);
      if (access_iter->access_type != kReadAccess) {
        // If this operation is of type kWriteAccess or kReadWriteAccess
        ans = std::max(ans, command_index);
        break;  // break from access_iter loop (an optimization)
      }
    }
  }
  return ans;
}

Member Data Documentation

analyzer_

const Analyzer& analyzer_

private

Definition at line 364 of file nnet-analyze.h.

computation_

const NnetComputation& computation_

private

Definition at line 363 of file nnet-analyze.h.

---

The documentation for this class was generated from the following files:

• nnet3/nnet-analyze.h
• nnet3/nnet-analyze.cc