Changeset 219


Ignore:
Timestamp:
May 9, 2011 3:46:59 AM (8 years ago)
Author:
awalther
Message:

change nonl_dom to arrays instead of linked list, improved implementation of merge_2_index_domains

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/ADOL-C/src/uni5_for.c

    r191 r219  
    88
    99 Contents: Contains the routines :
    10            zos_forward (zero-order-scalar forward mode):      define _ZOS_   
     10           zos_forward (zero-order-scalar forward mode):      define _ZOS_
    1111           fos_forward (first-order-scalar forward mode):     define _FOS_
    1212           hos_forward (higher-order-scalar forward mode):    define _HOS_
     
    1818           Uses the preprocessor to compile the 7 different object files
    1919           with/without "keep" parameter:                     define _KEEP_
    20  
    21  Copyright (c) Andrea Walther, Andreas Griewank, Andreas Kowarz,
    22                Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel
     20
     21 Copyright (c) Andrea Walther, Andreas Griewank, Andreas Kowarz,
     22               Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel,
     23               Benjamin Letschert
    2324
    2425 This file is part of ADOL-C. This software is provided as open source.
    25  Any use, reproduction, or distribution of the software constitutes 
     26 Any use, reproduction, or distribution of the software constitutes
    2627 recipient's acceptance of the terms of the accompanying license file.
    27  
     28
    2829----------------------------------------------------------------------------*/
    2930
     
    4243#endif /* ADOLC_DEBUG */
    4344
     45
    4446/****************************************************************************/
    4547/*                                                                   MACROS */
     
    122124#else
    123125#if defined(_INDO_)
    124 
    125126void copy_index_domain(int res, int arg, locint **ind_dom);
    126127void merge_2_index_domains(int res, int arg, locint **ind_dom);
     
    146147 */
    147148
    148 typedef struct IndexElement {
    149     locint  entry;
    150     struct IndexElement* next;
    151 }
    152 IndexElement;
    153 
    154149void extend_nonlinearity_domain_binary_step
    155 (int arg1, int arg2, locint **ind_dom, IndexElement **nonl_dom);
     150(int arg1, int arg2, locint **ind_dom, locint **nonl_dom);
    156151void extend_nonlinearity_domain_unary
    157 (int arg, locint **ind_dom, IndexElement **nonl_dom);
     152(int arg, locint **ind_dom, locint **nonl_dom);
    158153void extend_nonlinearity_domain_binary
    159 (int arg1, int arg2, locint **ind_dom, IndexElement **nonl_dom);
     154(int arg1, int arg2, locint **ind_dom, locint **nonl_dom);
     155
    160156
    161157#if defined(_TIGHT_)
     
    509505
    510506/* int_forward_tight( tag, m, n, p, x[n], X[n][p], y[m], Y[m][p]),
    511    
     507
    512508     nBV = number of Boolean Vectors to be packed
    513509                      (see Chapter Dependence Analysis, ADOL-C Documentation)
    514510     bits_per_long = 8*sizeof(unsigned long int)
    515511     p = nBV / bits_per_long + ( (nBV % bits_per_long) != 0 )
    516  
     512
    517513     The order of the indices in argument and taylors is [var][taylor]
    518  
    519      For the full Jacobian matrix set 
     514
     515     For the full Jacobian matrix set
    520516     p = indep / bits_per_long + ((indep % bits_per_long) != 0)
    521517     and pass a bit pattern version of the identity matrix as an argument   */
     
    562558
    563559/* indopro_forward_tight( tag, m, n, x[n], *crs[m]),
    564    
     560
    565561  */
    566562
     
    579575
    580576/* indopro_forward_safe( tag, m, n, x[n], *crs[m]),
    581    
     577
    582578  */
    583579#endif
     
    596592
    597593/* indopro_forward_tight( tag, m, n, x[n], *crs[m]),
    598    
     594
    599595  */
    600596
     
    612608
    613609/* indopro_forward_safe( tag, m, n, x[n], *crs[m]),
    614    
     610
    615611  */
    616612#endif
     
    744740#if defined(_NONLIND_)
    745741    /* nonlinear interaction domains */
    746     IndexElement** nonl_dom;
    747     IndexElement*  temp;
    748     IndexElement*  temp1;
     742    locint** nonl_dom;
     743    locint*  temp;
     744    locint*  temp1;
    749745#endif
    750746#endif
     
    981977    max_ind_dom = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES];
    982978#if defined(_NONLIND_)
    983     nonl_dom = (struct IndexElement**) malloc(sizeof(struct IndexElement*) * indcheck);
    984     for(i=0;i<indcheck;i++)
    985         nonl_dom[i] = NULL;
     979
     980    nonl_dom = (locint**) malloc(sizeof(locint*) * indcheck);
     981    for(i=0;i<indcheck;i++){
     982          nonl_dom[i] = (locint*) malloc(sizeof(locint)*(NUMNNZ+2));
     983          nonl_dom[i][0]=0;
     984          nonl_dom[i][1]=NUMNNZ;
     985       }
    986986#endif
    987987
     
    10471047#endif /* ADOLC_DEBUG */
    10481048    while (operation !=end_of_tape) {
    1049      
     1049
    10501050      switch (operation) {
    1051    
     1051
    10521052
    10531053                /****************************************************************************/
     
    18501850
    18511851#if defined(_INDO_)
    1852                 copy_index_domain(res, arg, ind_dom);               
     1852                copy_index_domain(res, arg, ind_dom);
    18531853#else
    18541854#if !defined(_ZOS_) /* BREAK_ZOS */
     
    28322832#if !defined(_INT_FOR_)
    28332833                T0arg   = dp_T0[arg];
    2834 #endif 
     2834#endif
    28352835#endif /* ALL_TOGETHER_AGAIN */
    28362836
     
    34483448                    FOR_0_LE_l_LT_pk
    34493449                    TRES_INC = TARG2_INC;
    3450 #endif 
     3450#endif
    34513451
    34523452                if (dp_T0[arg] > 0) {
     
    36373637                break;
    36383638#endif
    3639 
    3640                 /*--------------------------------------------------------------------------*/
     3639                /*--------------------------------------------------------------------------*/
     3640
    36413641            default:                                                   /* default */
    36423642                /* Die here, we screwed up */
     
    36563656#endif /* ADOLC_DEBUG */
    36573657    }  /* endwhile */
    3658 
    36593658
    36603659#if defined(ADOLC_DEBUG)
     
    37023701
    37033702#if defined(_NONLIND_)
    3704     for(i=0;i<indcheck;i++) {
    3705         if (nonl_dom[i] != NULL) {
    3706             crs[i] = (unsigned int*) malloc(sizeof(unsigned int) * (nonl_dom[i]->entry+1));
    3707             temp1 = nonl_dom[i];
    3708             temp = nonl_dom[i]->next;
    3709             crs[i][0] = nonl_dom[i]->entry;
    3710             free(temp1);
    3711             for(l=1;l<=crs[i][0];l++) {
    3712                 crs[i][l] = temp->entry;
    3713                 temp1 = temp;
    3714                 temp = temp->next;
    3715                 free(temp1);
    3716             }
    3717         } else {
    3718             crs[i] = (unsigned int *) malloc(sizeof(unsigned int));
    3719             crs[i][0] = 0;
    3720         }
     3703
     3704    for( i=0; i < indcheck; i++) {
     3705       crs[i] = (unsigned int*) malloc(sizeof(unsigned int) * (nonl_dom[i][0]+1));
     3706       crs[i][0] = nonl_dom[i][0];
     3707       for(l=1; l < crs[i][0]+1; l++)
     3708          crs[i][l] = nonl_dom[i][l+1];
     3709       free(nonl_dom[i]);
    37213710    }
    37223711    free(nonl_dom);
     
    37373726/* operations on index domains                                              */
    37383727
    3739 #ifdef _TIGHT_
     3728#if defined(_TIGHT_)
    37403729void copy_index_domain(int res, int arg, locint **ind_dom) {
    37413730
     
    37433732
    37443733   if (ind_dom[arg][0] > ind_dom[res][1]-2)
    3745     {
    3746         free(ind_dom[res]);
    3747         ind_dom[res] = (locint *)  malloc(sizeof(locint) * 2*ind_dom[arg][0]);
    3748         ind_dom[res][1] = 2*ind_dom[arg][0];
    3749     }
    3750    
     3734     {
     3735       free(ind_dom[res]);
     3736       ind_dom[res] = (locint *)  malloc(sizeof(locint) * 2*(ind_dom[arg][0])+1);
     3737       ind_dom[res][1] = 2*ind_dom[arg][0];
     3738     }
     3739
     3740
    37513741    for(i=2;i<ind_dom[arg][0]+2;i++)
    3752         ind_dom[res][i] = ind_dom[arg][i];
     3742       ind_dom[res][i] = ind_dom[arg][i];
    37533743    ind_dom[res][0] = ind_dom[arg][0];
    37543744}
    37553745
    37563746
    3757 void merge_2_index_domains(int res, int arg, locint **ind_dom) {
    3758 
    3759     int num,num1,i,j,k,l;
    3760     locint *temp_array, *temp_array1;
    3761 
    3762     if (ind_dom[res][0] == 0)
    3763         copy_index_domain(res,arg,ind_dom);
    3764     else
     3747void merge_2_index_domains(int res, int arg, locint **ind_dom)
     3748{
     3749
     3750  int num,num1,num2, i,j,k,l;
     3751  locint *temp_array, *arg_ind_dom, *res_ind_dom;
     3752
     3753  if (ind_dom[res][0] == 0)
     3754    copy_index_domain(res,arg,ind_dom);
     3755  else
    37653756    {
    3766         num = ind_dom[res][0];
    3767         temp_array = (locint *)  malloc(sizeof(locint)* num);
    3768         num1 = ind_dom[arg][0];
    3769         temp_array1 = (locint *)  malloc(sizeof(locint) * num1);
    3770        
    3771         for(i=0;i<num;i++)
    3772             temp_array[i] = ind_dom[res][i+2];
    3773         for(i=0;i<num1;i++)
    3774             temp_array1[i] = ind_dom[arg][i+2];
    3775 
    3776         if (num1+num > ind_dom[res][1]-2)
     3757      if (res != arg)
    37773758        {
    3778           i = 2*(num1+num);
    3779           free(ind_dom[res]);
    3780           ind_dom[res] = (locint *)  malloc(sizeof(locint) * i);
    3781           ind_dom[res][1] = i;
    3782         }
    3783         i = 0;
    3784         j = 0;
    3785         k = 2;
    3786         while ((i< num) && (j < num1))
     3759          arg_ind_dom = ind_dom[arg];
     3760          res_ind_dom = ind_dom[res];
     3761
     3762          num  = ind_dom[res][0];
     3763          num1 = arg_ind_dom[0];
     3764          num2 = ind_dom[res][1];
     3765
     3766          if (num2 < num1+num)
     3767            num2 = num1+num;
     3768         
     3769          temp_array = (locint *)  malloc(sizeof(locint)* (num2+2));
     3770          temp_array[1] = num2;
     3771
     3772          i = 2;
     3773          j = 2;
     3774          k = 2;
     3775          num += 2;
     3776          num1 += 2;
     3777          while ((i< num) && (j < num1))
    37873778            {
    3788               if (temp_array[i] < temp_array1[j])
     3779              if (res_ind_dom[i] < arg_ind_dom[j])
    37893780                {
    3790                   ind_dom[res][k] = temp_array[i];
     3781                  temp_array[k] = res_ind_dom[i];
    37913782                  i++; k++;
    37923783                }
    37933784              else
    3794               {
    3795                   if (temp_array[i] == temp_array1[j])
     3785                {
     3786                  if (res_ind_dom[i] == arg_ind_dom[j])
    37963787                    {
    3797                       ind_dom[res][k] = temp_array1[j];
     3788                      temp_array[k] = arg_ind_dom[j];
    37983789                      i++;j++;k++;
    37993790                    }
    38003791                  else
    38013792                    {
    3802                       ind_dom[res][k] = temp_array1[j];
     3793                      temp_array[k] = arg_ind_dom[j];
    38033794                      j++;k++;               
    38043795                    }
     
    38063797            }
    38073798          for(l = i;l<num;l++)
    3808           {
    3809               ind_dom[res][k] = temp_array[l];
     3799            {
     3800              temp_array[k] = res_ind_dom[l];
    38103801              k++;
    3811           }
     3802            }
    38123803          for(l = j;l<num1;l++)
    3813           {
    3814               ind_dom[res][k] = temp_array1[l];
     3804            {
     3805              temp_array[k] = arg_ind_dom[l];
    38153806              k++;
    3816           }
    3817           ind_dom[res][0] = k-2;
    3818           free(temp_array);
    3819           free(temp_array1);
     3807            }
     3808          temp_array[0] = k-2;
     3809          free(ind_dom[res]);
     3810          ind_dom[res]=temp_array;
     3811        }
    38203812    }
    38213813
     3814
    38223815}
    38233816
     
    38253818
    38263819    if (res != arg1)
    3827         copy_index_domain(res, arg1, ind_dom);
     3820       copy_index_domain(res, arg1, ind_dom);
    38283821
    38293822    merge_2_index_domains(res, arg2, ind_dom);
     
    38343827    merge_2_index_domains(res, arg2, ind_dom);
    38353828}
     3829
     3830
     3831
    38363832#endif
    38373833#endif
     
    38423838
    38433839void extend_nonlinearity_domain_binary_step
    3844 (int arg1, int arg2, locint **ind_dom, IndexElement **nonl_dom) {
    3845 
    3846     int index;
    3847     int num,num1, i,j,l,m;
    3848     IndexElement* temp_nonl;
    3849     IndexElement* nonl_num;
    3850     IndexElement* temp1;
    3851 
     3840(int arg1, int arg2, locint **ind_dom, locint **nonl_dom) {
     3841    int index,num,num1, i,j,k,l,m;
     3842    locint* temp_nonl;
    38523843    num = ind_dom[arg2][0];
    38533844
    3854     for(m=2;m<ind_dom[arg1][0]+2;m++)
    3855     {
    3856         index = ind_dom[arg1][m];
    3857         temp_nonl = nonl_dom[index];
    3858         if (temp_nonl == NULL) {
    3859             temp_nonl = (struct IndexElement*)
    3860                 malloc(sizeof(struct IndexElement));
    3861             nonl_dom[index] = temp_nonl;
    3862             temp_nonl->entry = 0;
    3863             temp_nonl->next = NULL;
    3864         }
    3865         nonl_num = temp_nonl; /* kept for updating the element count */
    3866         if (nonl_num->entry == 0) { /* empty list */
    3867           for(i=2;i<num+2;i++)      /* append index domain list of "arg" */
    3868             {
    3869               temp_nonl->next = (struct IndexElement*) malloc(sizeof(struct IndexElement));
    3870               temp_nonl = temp_nonl->next;
    3871               temp_nonl->entry = ind_dom[arg2][i];
    3872               temp_nonl->next = NULL;
    3873               nonl_num->entry++;
    3874             }
    3875         }
    3876        else /* merge lists */
    3877          {
    3878            num1 = temp_nonl->entry;
    3879            temp_nonl = temp_nonl->next; /* skip counter */
    3880            i = 0;
    3881            j = 2;
    3882            temp_nonl = nonl_num;
    3883            temp_nonl = temp_nonl->next;
    3884            while ((i<num1) && (j < num+2))
    3885              {
    3886                if (ind_dom[arg2][j] < temp_nonl->entry) /* < */
    3887                  {
    3888                    temp1 = (struct IndexElement*) malloc(sizeof(struct IndexElement));
    3889                    temp1->next = temp_nonl->next;
    3890                    temp1->entry = temp_nonl->entry;
    3891                    temp_nonl->entry = ind_dom[arg2][j];
    3892                    temp_nonl->next = temp1;
    3893                    temp_nonl=temp_nonl->next;
    3894                    nonl_num->entry++;
    3895                    j++;
    3896                  }
    3897                else
    3898                  {
    3899                    if (ind_dom[arg2][j] == temp_nonl->entry)  /* == */
    3900                      {
    3901                        j++;
    3902                      }
    3903                    else
    3904                      {
    3905                        i++;
    3906                        if (i<num1)
    3907                          temp_nonl = temp_nonl->next;
    3908                      }
     3845    for(m=2;m<ind_dom[arg1][0]+2;m++) {
     3846          index = ind_dom[arg1][m];
     3847       if (nonl_dom[index][0] == 0) { /* empty list */
     3848          if ( nonl_dom[index][1] < num){
     3849             free(nonl_dom[index]);
     3850             nonl_dom[index] = (locint*) malloc(sizeof(locint)*2*(num+1) );
     3851             nonl_dom[index][1] = 2*num;
     3852          }
     3853          for(i=2;i<num+2;i++)      /* append index domain list of "arg" */
     3854                nonl_dom[index][i] = ind_dom[arg2][i];
     3855          nonl_dom[index][0] = num;
     3856          } else { /* merge lists */
     3857             num1 = nonl_dom[index][0];
     3858          temp_nonl = (locint*) malloc(sizeof(locint)*num1);
     3859          for(i=0;i<num1; i++)
     3860             temp_nonl[i] = nonl_dom[index][i+2];
     3861
     3862          if ( (nonl_dom[index][1]) < (num+num1) ){
     3863             free(nonl_dom[index]);
     3864             nonl_dom[index] = (locint*) malloc(sizeof(locint)*2*(num+num1+1) );
     3865             nonl_dom[index][1] = 2*(num+num1);
     3866          }
     3867
     3868          i = 0;
     3869          k = 2;
     3870          j = 2;
     3871          while ((i<num1) && (j < num+2)){
     3872                if (ind_dom[arg2][j] < temp_nonl[i]) /* < */ {
     3873                   nonl_dom[index][k] = ind_dom[arg2][j];
     3874                   j++; k++;
     3875                 } else {
     3876                   if (ind_dom[arg2][j] == temp_nonl[i])  /* == */ {
     3877             nonl_dom[index][k] = ind_dom[arg2][j];
     3878             j++; k++; i++;
     3879             } else {
     3880               nonl_dom[index][k] = temp_nonl[i];
     3881               i++; k++;
     3882                }
    39093883                 }
    39103884             }
    3911            for(l = j;l<num+2;l++)
    3912              {
    3913                temp1 = (struct IndexElement*) malloc(sizeof(struct IndexElement));
    3914                temp_nonl->next = temp1;
    3915                temp_nonl = temp_nonl->next;
    3916                temp_nonl->entry = ind_dom[arg2][l];
    3917                temp_nonl->next = NULL;
    3918                nonl_num->entry++;
    3919              }
     3885           for(l = j;l<num+2;l++) {
     3886               nonl_dom[index][k] = ind_dom[arg2][l];
     3887            k++;
     3888           }
     3889        for(l = i;l<num1;l++) {
     3890            nonl_dom[index][k] = temp_nonl[l];
     3891            k++;
     3892        }
     3893        nonl_dom[index][0] = k-2;
     3894        free((char*) temp_nonl);
    39203895         }
    39213896    }
     
    39233898
    39243899void extend_nonlinearity_domain_unary
    3925 (int arg, locint **ind_dom, IndexElement **nonl_dom) {
     3900(int arg, locint **ind_dom, locint **nonl_dom) {
    39263901    extend_nonlinearity_domain_binary_step(arg, arg, ind_dom, nonl_dom);
    39273902}
    39283903
    39293904void extend_nonlinearity_domain_binary
    3930 (int arg1, int arg2, locint **ind_dom, IndexElement **nonl_dom) {
     3905(int arg1, int arg2, locint **ind_dom, locint **nonl_dom) {
    39313906    extend_nonlinearity_domain_binary_step(arg1, arg2, ind_dom, nonl_dom);
    39323907    extend_nonlinearity_domain_binary_step(arg2, arg1, ind_dom, nonl_dom);
    39333908}
    39343909
     3910
    39353911#endif
    39363912#endif
Note: See TracChangeset for help on using the changeset viewer.