kitPerm.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "kit.h"

Include dependency graph for kitPerm.c:

Go to the source code of this file.

Macros
#define	inline   __inline
#define	NFUNCS   (1<<20)

Typedefs
typedef unsigned __int64	word
	DECLARATIONS ///.
typedef unsigned short	shot

Functions
void	Kit_PermCreateS ()
	FUNCTION DEFINITIONS ///.
void	Kit_PermCreateP ()
void	Kit_PermCompute (word *o, word *i, int V)
void	Kit_PermComputeNaive (word *F, int nVars)
word	M (word f1, word f2, int n)
word	Tf (word f, int n)
void	Kit_PermComputeTest ()
void	Kit_PermComputeTest_ ()

Macro Definition Documentation

inline

#define inline   __inline

CFile****************************************************************

FileName [kitPerm.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Computation kit.]

Synopsis [Procedures for permuting truth tables.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - Oct 26, 2011.]

Revision [

Id

kitPerm.c,v 1.00 2011/11/26 00:00:00 alanmi Exp

]

Definition at line 28 of file kitPerm.c.

NFUNCS

#define NFUNCS   (1<<20)

Definition at line 265 of file kitPerm.c.

Typedef Documentation

shot

typedef unsigned short shot

Definition at line 37 of file kitPerm.c.

word

typedef unsigned __int64 word

DECLARATIONS ///.

Definition at line 36 of file kitPerm.c.

Function Documentation

Kit_PermCompute()

void Kit_PermCompute	(	word *	o,
		word *	i,
		int	V )

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 199 of file kitPerm.c.

{
    word * t;
    int v, n = (1 << (V-3));
    assert( V >= 6 && V <= 16 );
    for ( v = 0; v < n; v++ )
        ((byte *)i)[v] = P[((byte *)i)[v]];
    for ( v = 3; v < V; v++ )
    {
        Kit_PermCycleMany( (shot *)o, (byte *)i, V, v );
        t = i; i = o; o = t;
    }
    if ( V & 1 )
    {
        n = (1 << (V-6));
        for ( v = 0; v < n; v++ )
            o[v] = i[v];
    }
}

Here is the caller graph for this function:

Kit_PermComputeNaive()

void Kit_PermComputeNaive	(	word *	F,
		int	nVars )

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 230 of file kitPerm.c.

{
    extern void If_CluReverseOrder( word * pF, int nVars, int * V2P, int * P2V, int iVarStart );
    int i, V2P[16], P2V[16];
    for ( i = 0; i < nVars; i++ )
        V2P[i] = P2V[i] = i;
    If_CluReverseOrder( F, nVars, V2P, P2V, 0 );
}

Here is the call graph for this function:

Kit_PermComputeTest()

void Kit_PermComputeTest

(

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 278 of file kitPerm.c.

{
    word * T = (word *)malloc( 8 * NFUNCS );
    word i, o, w = 0;
    int k, b;
    abctime clk;
 
    srand( 0 );
 
    clk = Abc_Clock();
    for ( k = 0; k < NFUNCS; k++ )
        for ( b = 0; b < 8; b++ )
            ((byte *)(T + k))[b] = (byte)(rand() & 0xFF);
    ABC_PRT( "Assign", Abc_Clock() - clk );
 
//    T[0] = 0xacaccacaaccaacca;
//    Kit_DsdPrintFromTruth( T, 6 );
 
    // perform measurements
    clk = Abc_Clock();
    for ( k = 0; k < NFUNCS; k++ )
    {
        i = T[k];
//        Kit_PermComputeNaive( &i, 6 );
        Tf( i, 6 );
    }
    ABC_PRT( "Perm1 ", Abc_Clock() - clk );
 
    // perform measurements
    clk = Abc_Clock();
    for ( k = 0; k < NFUNCS; k++ )
    {
        i = T[k];
        Kit_PermCompute( &o, &i, 6 );
 
//        w = T[k];
//        Kit_PermComputeNaive( &w, 6 );
//        assert( w == o );
    }
    ABC_PRT( "Perm2 ", Abc_Clock() - clk );
 
    assert( w == 0 );
    free( T );
}

Here is the call graph for this function:

Kit_PermComputeTest_()

void Kit_PermComputeTest_

(

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso [] `

Definition at line 334 of file kitPerm.c.

{
    word t, s;
    t = 0xacaccacaaccaacca;
//    Kit_DsdPrintFromTruth( &t, 6 ); printf( "\n" );
    s = Tf( t, 6 );
//    Kit_PermComputeNaive( &t, 6 );
//    Kit_DsdPrintFromTruth( &s, 6 ); printf( "\n" );
}

Here is the call graph for this function:

Kit_PermCreateP()

void Kit_PermCreateP

(

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 135 of file kitPerm.c.

{
    int i, s1, s2, r;
    for ( i = 0; i < 256; i++ )
    {
        if ( i % 16 == 0 )
            printf( "\n" );
        s1 = i & 0x0A;
        s2 = i & 0x50;
        r = i ^ s1 ^ s2 ^ (s1 << 3) ^ (s2 >> 3);
        assert( r < 256 );
        printf( "0x%02x, ", r );
    }
}

Kit_PermCreateS()

void Kit_PermCreateS

(

)

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 111 of file kitPerm.c.

{
    int i, n, r;
    for ( i = 0; i < 256; i++ )
    {
        if ( i % 8 == 0 )
            printf( "\n" );
        for ( r = n = 0; n < 8; n++ )
            r |= ((i & (1 << n)) << n);
        printf( "0x%04x, ", r );
    }
}

M()

word M	(	word	f1,
		word	f2,
		int	n )

Definition at line 240 of file kitPerm.c.

{
    word temp = 0;
    word a = 1;
    int i;
    for(  i = 0; i < n; i++)
        temp = temp + (((f1>>i)&a) << (2*i) ) + (((f2>>i)&a) << (2*i+1));
    return temp;
}

Here is the caller graph for this function:

Tf()

word Tf	(	word	f,
		int	n )

Definition at line 250 of file kitPerm.c.

{
    if(n==1)
        return f;
    else
    {
//        int x = (int)pow(2,n-1);
        int x;
        x = (1 << (n-1));
        return (  M (Tf( (f << x) >> x, n-1), Tf( (f >> x), n-1), x) );     //def. of M just below the function
     }
}

Here is the call graph for this function:

Here is the caller graph for this function: