acd::acdXX_impl Class Reference

#include <acdXX.hpp>

Public Member Functions
	acdXX_impl (uint32_t const num_vars, acdXX_params const &ps={})
bool	run (word *ptt)
	Runs ACD XX.
int	run (word *ptt, unsigned delay_profile)
	Runs ACD XX.
int	compute_decomposition ()
uint32_t	get_num_edges ()
unsigned	get_profile ()
void	get_decomposition (unsigned char *decompArray)

Detailed Description

Definition at line 67 of file acdXX.hpp.

Constructor & Destructor Documentation

acdXX_impl()

acd::acdXX_impl::acdXX_impl ( uint32_t const num_vars, acdXX_params const & ps = {} )

inlineexplicit

Definition at line 75 of file acdXX.hpp.

                                                                         {} )
      : num_vars( num_vars ), ps( ps )
  {
    std::iota( permutations.begin(), permutations.end(), 0 );
  }

Member Function Documentation

compute_decomposition()

int acd::acdXX_impl::compute_decomposition ( )

inline

Definition at line 133 of file acdXX.hpp.

  {
    if ( best_multiplicity == UINT32_MAX )
      return -1;
 
    compute_decomposition_impl();
 
    if ( ps.verify && !verify_impl() )
    {
      return 1;
    }
 
    return 0;
  }

get_decomposition()

void acd::acdXX_impl::get_decomposition ( unsigned char * decompArray )

inline

Definition at line 186 of file acdXX.hpp.

  {
    if ( bs_support_size == UINT32_MAX )
      return;
 
    get_decomposition_abc( decompArray );
  }

get_num_edges()

uint32_t acd::acdXX_impl::get_num_edges ( )

inline

Definition at line 148 of file acdXX.hpp.

  {
    if ( bs_support_size == UINT32_MAX )
    {
      return num_vars + 1 + num_shared_vars;
    }
 
    /* real value after support minimization */
    return bs_support_size + best_free_set + 1 + num_shared_vars;
  }

get_profile()

unsigned acd::acdXX_impl::get_profile ( )

inline

Definition at line 160 of file acdXX.hpp.

  {
    unsigned profile = 0;
 
    if ( best_multiplicity == UINT32_MAX )
      return -1;
    
    if ( bs_support_size == UINT32_MAX )
    {
      for ( uint32_t i = 0; i < best_free_set; ++i )
      {
        profile |= 1 << permutations[i];
      }
    }
    else
    {
      for ( uint32_t i = 0; i < bs_support_size; ++i )
      {
        profile |= 1 << permutations[bs_support[i] + best_free_set];
      }
      profile = ~profile & ( ( 1u << num_vars ) - 1 );
    }
 
    return profile;
  }

run() [1/2]

bool acd::acdXX_impl::run ( word * ptt )

inline

Runs ACD XX.

Definition at line 82 of file acdXX.hpp.

  {
    assert( num_vars > 4 );
 
    /* truth table is too large for the settings */
    if ( num_vars > max_num_vars || num_vars >= 2 * ps.lut_size )
    {
      return false;
    }
 
    /* saturate the maximum number of shared variables */
    ps.max_shared_vars = std::min( ps.max_shared_vars, ps.lut_size - 2 );
 
    /* convert to static TT */
    init_truth_table( ptt );
 
    /* run ACD trying different bound sets and free sets */
    return find_decomposition();
  }

run() [2/2]

int acd::acdXX_impl::run ( word * ptt, unsigned delay_profile )

inline

Runs ACD XX.

Definition at line 103 of file acdXX.hpp.

  {
    assert( num_vars > 4 );
 
    /* truth table is too large for the settings */
    if ( num_vars > max_num_vars || num_vars >= 2 * ps.lut_size )
    {
      return 0;
    }
 
    uint32_t late_arriving = __builtin_popcount( delay_profile );
 
    /* too many late arriving variables */
    if ( late_arriving >= ps.lut_size )
      return 0;
 
    /* saturate the maximum number of shared variables */
    ps.max_shared_vars = std::min( ps.max_shared_vars, ps.lut_size - 2 );
 
    /* convert to static TT */
    init_truth_table( ptt );
    best_tt = start_tt;
 
    /* permute late arriving variables to be the least significant */
    reposition_late_arriving_variables( delay_profile, late_arriving );
 
    /* run ACD trying different bound sets and free sets */
    return find_decomposition_offset( late_arriving ) ? ( delay_profile == 0 ? 2 : 1 ) : 0;
  }

---

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

• src/map/if/acd/acdXX.hpp