Changeset 264


Ignore:
Timestamp:
Jul 14, 2011 3:15:25 PM (9 years ago)
Author:
awalther
Message:

nlfsworking but slow

File:
1 edited

Legend:

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

    r263 r264  
    981981    ADOLC_CURRENT_TAPE_INFOS.dp_T0 = dp_T0;
    982982#endif /* !_NTIGHT_ */
     983
    983984#if defined(_ZOS_)                                                   /* ZOS */
    984985
     
    10401041#else
    10411042        ind_dom = (locint **)  malloc(sizeof(locint*) * (ADOLC_CURRENT_TAPE_INFOS.stats[NUM_OPERATIONS]+ADOLC_CURRENT_TAPE_INFOS.stats[NUM_EQ_PROD]));
    1042         nlf = (locint **)  malloc(sizeof(locint*) * (ADOLC_CURRENT_TAPE_INFOS.stats[NUM_OPERATIONS]+ADOLC_CURRENT_TAPE_INFOS.stats[NUM_EQ_PROD]));   
    1043         arg_index = (locint *)  malloc(sizeof(locint) * (ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]));   
     1043/*      nlf = (locint **)  malloc(sizeof(locint*) * (ADOLC_CURRENT_TAPE_INFOS.stats[NUM_OPERATIONS]+ADOLC_CURRENT_TAPE_INFOS.stats[NUM_EQ_PROD]));     */
     1044        arg_index = (locint *)  malloc(sizeof(locint) * (ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]));
    10441045        opind = 0;
    10451046        max_ind_dom = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_OPERATIONS]+ADOLC_CURRENT_TAPE_INFOS.stats[NUM_EQ_PROD];
     
    10541055
    10551056#if defined(_NONLIND_)
    1056 
    10571057    nonl_dom = (locint**) malloc(sizeof(locint*) * indcheck);
    10581058    for(i=0;i<indcheck;i++){
     
    11251125    while (operation !=end_of_tape) {
    11261126 
    1127 /* #if defined(_NLF_) */
    11281127/*       printf(" op %d \n",operation); */
    1129 /* #endif */
    11301128      switch (operation) {
    11311129
     
    13261324                ind_dom[opind] = (locint *)  malloc(sizeof(locint) * 1);
    13271325                ind_dom[opind][0] = 0;
    1328                 nlf[opind] = (locint *)  malloc(sizeof(locint) * 1);
    1329                 nlf[opind][0] = 0;
     1326/*              nlf[opind] = (locint *)  malloc(sizeof(locint) * 1); */
     1327/*              nlf[opind][0] = 0; */
    13301328                arg_index[res] = opind++;               
    13311329#endif
     
    13571355                ind_dom[opind] = (locint *)  malloc(sizeof(locint) * 1);
    13581356                ind_dom[opind][0] = 0;
    1359                 nlf[opind] = (locint *)  malloc(sizeof(locint) * 1);
    1360                 nlf[opind][0] = 0;
     1357/*              nlf[opind] = (locint *)  malloc(sizeof(locint) * 1); */
     1358/*              nlf[opind][0] = 0; */
    13611359                arg_index[res] = opind++;               
    13621360#endif
     
    13881386                ind_dom[opind] = (locint *)  malloc(sizeof(locint) * 1);
    13891387                ind_dom[opind][0] = 0;
    1390                 nlf[opind] = (locint *)  malloc(sizeof(locint) * 1);
    1391                 nlf[opind][0] = 0;
     1388/*              nlf[opind] = (locint *)  malloc(sizeof(locint) * 1); */
     1389/*              nlf[opind][0] = 0; */
    13921390                arg_index[res] = opind++;               
    13931391#endif
     
    14221420                ind_dom[opind][0] = 1;
    14231421                ind_dom[opind][1] = opind;
    1424                 nlf[opind] = (locint *)  malloc(sizeof(locint) * 1);
    1425                 nlf[opind][0] = 0;
     1422/*              nlf[opind] = (locint *)  malloc(sizeof(locint) * 1); */
     1423/*              nlf[opind][0] = 0; */
    14261424                arg_index[res] = opind++;               
    14271425#endif         
     
    14711469#if defined(_NLF_)
    14721470               
    1473                 for(l=1;l<nlf[arg_index[res]][0]+1;l++)
    1474                   {
    1475                     int index = nlf[arg_index[res]][l];
    1476                     for(ii=1;ii<ind_dom[index][0]+1;ii++)
    1477                       {
    1478                         index1 = ind_dom[index][ii];
    1479                         for(jj=1;jj<ind_dom[index][0]+1;jj++)
    1480                           {
    1481                             temp1 = csod[index1];
    1482                             temp = csod[index1]->next;
    1483                             num = csod[index1]->entry;
    1484                             i=0;
    1485                             do
    1486                               {
    1487                                 if (temp==NULL)
    1488                                   {
    1489                                     temp = (struct IndexElement*) malloc(sizeof(struct IndexElement));
    1490                                     temp1->next = temp;
    1491                                     temp->entry = ind_dom[index][jj];
    1492                                     temp->next = NULL;
    1493                                     csod[index1]->entry++;
    1494                                     i = 1;
    1495                                   }
    1496                                 else
    1497                                   {
    1498                                     if (temp->entry < ind_dom[index][jj])
    1499                                       {
    1500                                         temp1 = temp;
    1501                                         temp = temp->next;
    1502                                       }
    1503                                     else
    1504                                       {
    1505                                         if (temp->entry == ind_dom[index][jj])
    1506                                           i = 1;
    1507                                         else
    1508                                           {
    1509                                             temp = (struct IndexElement*) malloc(sizeof(struct IndexElement));
    1510                                             temp->entry = ind_dom[index][jj];
    1511                                             csod[index1]->entry++;
    1512                                             temp->next = temp1->next;
    1513                                             temp1->next = temp;
    1514                                             i=1;
    1515                                           }
    1516                                       }
    1517                                   }
    1518                               }
    1519                             while (i == 0);
    1520                           }
    1521                       }
    1522                   }
     1471/*              for(l=1;l<nlf[arg_index[res]][0]+1;l++) */
     1472/*                { */
     1473/*                  int index = nlf[arg_index[res]][l]; */
     1474/*                  for(ii=1;ii<ind_dom[index][0]+1;ii++) */
     1475/*                    { */
     1476/*                      index1 = ind_dom[index][ii]; */
     1477/*                      for(jj=1;jj<ind_dom[index][0]+1;jj++) */
     1478/*                        { */
     1479/*                          temp1 = csod[index1]; */
     1480/*                          temp = csod[index1]->next; */
     1481/*                          num = csod[index1]->entry; */
     1482/*                          i=0; */
     1483/*                          do */
     1484/*                            { */
     1485/*                              if (temp==NULL) */
     1486/*                                { */
     1487/*                                  temp = (struct IndexElement*) malloc(sizeof(struct IndexElement)); */
     1488/*                                  temp1->next = temp; */
     1489/*                                  temp->entry = ind_dom[index][jj]; */
     1490/*                                  temp->next = NULL; */
     1491/*                                  csod[index1]->entry++; */
     1492/*                                  i = 1; */
     1493/*                                } */
     1494/*                              else */
     1495/*                                { */
     1496/*                                  if (temp->entry < ind_dom[index][jj]) */
     1497/*                                    { */
     1498/*                                      temp1 = temp; */
     1499/*                                      temp = temp->next; */
     1500/*                                    } */
     1501/*                                  else */
     1502/*                                    { */
     1503/*                                      if (temp->entry == ind_dom[index][jj]) */
     1504/*                                        i = 1; */
     1505/*                                      else */
     1506/*                                        { */
     1507/*                                          temp = (struct IndexElement*) malloc(sizeof(struct IndexElement)); */
     1508/*                                          temp->entry = ind_dom[index][jj]; */
     1509/*                                          csod[index1]->entry++; */
     1510/*                                          temp->next = temp1->next; */
     1511/*                                          temp1->next = temp; */
     1512/*                                          i=1; */
     1513/*                                        } */
     1514/*                                    } */
     1515/*                                } */
     1516/*                            } */
     1517/*                          while (i == 0); */
     1518/*                        } */
     1519/*                    } */
     1520/*                } */
    15231521#endif
    15241522#else
     
    15751573#else
    15761574                combine_2_domains(opind, arg_index[res], arg_index[arg], ind_dom);
    1577                 combine_2_domains(opind, arg_index[res], arg_index[arg], nlf);
     1575/*                 combine_2_domains(opind, arg_index[res], arg_index[arg], nlf); */
    15781576                arg_index[res] = opind++;               
    15791577#endif
     
    16241622#else
    16251623                combine_2_domains(opind, arg_index[res], arg_index[arg], ind_dom);
    1626                 combine_2_domains(opind, arg_index[res], arg_index[arg], nlf);
     1624/*                 combine_2_domains(opind, arg_index[res], arg_index[arg], nlf); */
    16271625                arg_index[res] = opind++;               
    16281626#endif
     
    16821680#else
    16831681                combine_2_domains(opind, arg_index[res], arg_index[arg], ind_dom);
    1684                 nlf[opind] = (locint *)  malloc(sizeof(locint) * 2);
    1685                 nlf[opind][0] = 1;
    1686                 nlf[opind][1] = opind;
     1682/*              nlf[opind] = (locint *)  malloc(sizeof(locint) * 2); */
     1683/*              nlf[opind][0] = 1; */
     1684/*              nlf[opind][1] = opind; */
    16871685                arg_index[res] = opind++;               
    16881686#endif
     
    17671765#else     
    17681766                combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
    1769                 combine_2_domains(opind, arg_index[arg1], arg_index[arg2], nlf);
     1767/*                 combine_2_domains(opind, arg_index[arg1], arg_index[arg2], nlf); */
    17701768                arg_index[res] = opind++;               
    17711769#endif
     
    18391837#else
    18401838                combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
    1841                 combine_2_domains(opind, arg_index[arg1], arg_index[arg2], nlf);
     1839/*                 combine_2_domains(opind, arg_index[arg1], arg_index[arg2], nlf); */
    18421840                arg_index[res] = opind++;               
    18431841#endif
     
    19081906                combine_2_index_domains(res, arg1, arg2, ind_dom);
    19091907#else
    1910                 combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
    1911                 nlf[opind] =  (locint *)  malloc(sizeof(locint) * 2);
    1912                 nlf[opind][0] = 1;
    1913                 nlf[opind][1] = opind;
    1914                 arg_index[res] = opind++;               
     1908                combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
     1909/*              nlf[opind] =  (locint *)  malloc(sizeof(locint) * 2);  */
     1910/*              nlf[opind][0] = 1; */
     1911/*              nlf[opind][1] = opind; */
     1912                arg_index[res] = opind++;               
    19151913#endif
    19161914#if defined(_NONLIND_)
     
    19721970                combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
    19731971                // first step: z = u*w, nlf
    1974                 nlf[opind] = (locint *)  malloc(sizeof(locint) * 2);
    1975                 nlf[opind][0] = 1;
    1976                 nlf[opind][1] = opind++;
     1972/*              nlf[opind] = (locint *)  malloc(sizeof(locint) * 2); */
     1973/*              nlf[opind][0] = 1; */
     1974/*              nlf[opind][1] = opind++; */
    19771975                // second step: v = v+z, index domains
    19781976                combine_2_domains(opind, arg_index[res], opind-1,ind_dom);
    19791977                // second step: v = v+z, nlf
    1980                 nlf[opind] = (locint *)  malloc(sizeof(locint) * (arg_index[res]+2));
    1981                 for(l=0;l<arg_index[res]+1;l++)
    1982                   nlf[opind][l] = nlf[opind-1][l];
    1983                 nlf[opind][arg_index[res]+1] = opind-1;
    1984                 nlf[opind][0]++;
    1985                 /* combine_2_domains(opind, arg_index[res], opind-1,nlf); */
     1978/*              nlf[opind] = (locint *)  malloc(sizeof(locint) * (nlf[arg_index[res]][0]+2)); */
     1979/*              for(l=0;l<nlf[arg_index[res]][0]+1;l++) */
     1980/*                nlf[opind][l] = nlf[arg_index[res]][l]; */
     1981/*              nlf[opind][nlf[arg_index[res]][0]+1] = opind-1; */
     1982/*              nlf[opind][0]++; */
    19861983                arg_index[res] = opind++;               
    1987                 /* combine_2_domains(opind, arg_index[res], opind-1,nlf); */
    1988                 /* arg_index[res] = opind++;             */
    19891984#endif
    19901985#if defined(_NONLIND_)
     
    20452040                combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
    20462041                // first step: z = u*w, nlf
    2047                 nlf[opind] = (locint *)  malloc(sizeof(locint) * 2);
    2048                 nlf[opind][0] = 1;
    2049                 nlf[opind][1] = opind++;
     2042/*              nlf[opind] = (locint *)  malloc(sizeof(locint) * 2); */
     2043/*              nlf[opind][0] = 1; */
     2044/*              nlf[opind][1] = opind++; */
    20502045                // second step: v = v+z, index domains
    20512046                combine_2_domains(opind, arg_index[res], opind-1,ind_dom);
    20522047                // second step: v = v+z, nlf
    2053                 combine_2_domains(opind, arg_index[res], opind-1,nlf);
     2048/*              nlf[opind] = (locint *)  malloc(sizeof(locint) * (nlf[arg_index[res]][0]+2)); */
     2049/*              for(l=0;l<nlf[arg_index[res]][0]+1;l++) */
     2050/*                nlf[opind][l] = nlf[arg_index[res]][l]; */
     2051/*              nlf[opind][nlf[arg_index[res]][0]+1] = opind-1; */
     2052/*              nlf[opind][0]++; */
    20542053                arg_index[res] = opind++;               
    20552054#endif
     
    21562155#else
    21572156                combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
    2158                 nlf[opind] = (locint *)  malloc(sizeof(locint) * 2);
    2159                 nlf[opind][0] = 1;
    2160                 nlf[opind][1] = opind;
     2157/*              nlf[opind] = (locint *)  malloc(sizeof(locint) * 2); */
     2158/*              nlf[opind][0] = 1; */
     2159/*              nlf[opind][1] = opind; */
    21612160                arg_index[res] = opind++;               
    21622161#endif
     
    35283527                          {
    35293528                            combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
    3530                             combine_2_domains(opind, arg_index[arg1], arg_index[arg2], nlf);
     3529/*                          combine_2_domains(opind, arg_index[arg1], arg_index[arg2], nlf); */
    35313530                          }
    35323531                    }
    35333532#else
    35343533                            combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
    3535                             combine_2_domains(opind, arg_index[arg1], arg_index[arg2], nlf);
     3534/*                          combine_2_domains(opind, arg_index[arg1], arg_index[arg2], nlf); */
    35363535#endif
    35373536                arg_index[res] = opind++;               
     
    38463845#else
    38473846                combine_2_domains(opind, arg_index[arg1], arg_index[arg2], ind_dom);
    3848                 combine_2_domains(opind, arg_index[arg1], arg_index[arg2], nlf);
     3847/*                 combine_2_domains(opind, arg_index[arg1], arg_index[arg2], nlf); */
    38493848                arg_index[res] = opind++;               
    38503849#endif
     
    41864185      {
    41874186        free(ind_dom[i]);
    4188         free(nlf[i]);
     4187/*      free(nlf[i]); */
    41894188      }
    41904189    free(ind_dom);
    4191     free(nlf);
     4190/*     free(nlf); */
    41924191    free(arg_index);
    41934192#endif
     
    42334232
    42344233    for(i=2;i<ind_dom[arg][0]+2;i++)
    4235        ind_dom[res][i] = ind_dom[arg][i];
     4234      {
     4235        ind_dom[res][i] = ind_dom[arg][i];
     4236      }
    42364237    ind_dom[res][0] = ind_dom[arg][0];
    42374238}
     
    42574258          num2 = ind_dom[res][1];
    42584259
    4259           if (num2 < num1+num)
    4260             num2 = num1+num;
     4260          if (num2 < num1+num+2)
     4261            num2 = num1+num+2;
    42614262         
    42624263          temp_array = (locint *)  malloc(sizeof(locint)* (num2+2));
     
    43044305        }
    43054306    }
    4306 
    4307 
    43084307}
    43094308
     
    43604359          num2 = index_nonl_dom[1];
    43614360         
    4362           if (num1+num > num2)
     4361          if (num1+num > num2-2)
    43634362            num2 = num1+num;
    43644363         
     
    44344433  int num1,num2, i,j,k,l;
    44354434
    4436   /* printf("c2d %d %d %d \n",res,arg1,arg2); */
     4435/*  printf("c2d %d %d %d \n",res,arg1,arg2); */
    44374436  num1 = dom[arg1][0];
    44384437  num2 = dom[arg2][0];
Note: See TracChangeset for help on using the changeset viewer.