OpenAD/code_regress/loopwrapper.C

#include <iostream>

class CP { 
public: 
  static const int levels=4; // the number of levels
  int maxIter;    // maximal iteration
  int aL[levels]; // allowed per level
  int uL[levels]; // used per level
  int iL[levels]; // current iteration per level
  int changedLevel; // level changed due to increment or decrement
  int topLevel;   // the top Level
  int cpLevel;    // current checkpoint level
  int tapeLevel;  // current taping level
  int adjointLevel; // current adjoint level

  CP() {
    maxIter=0;
    for (int i=0;i<levels;i++) { 
      iL[i]=aL[i]=uL[i]=ufL[i]=0;
    }
    topLevel=0;
    cpLevel=0;
    tapeLevel=0;
    adjointLevel=0;
  }

  void init(){ 
    // determine top level
    topLevel=0;
    int steps=1;
    for(int i=0;i<levels;i++) { 
      steps*=aL[i];
      if (steps<maxIter) 
        topLevel++;
      else
        break; 
    }
    if (topLevel>=levels) { 
      std::cerr << "insufficient checkpoints" << std::endl; 
    }
    for(int i=0;i<topLevel;i++) { 
      iL[i]=1;
    }
    // determine uses: 
    steps/=aL[topLevel];
    uL[topLevel]=1+maxIter/steps;
    for(int i=topLevel-1;i>=0;i--) { 
      uL[i]=aL[i];
    }
    // determine final uses: 
    ufL[topLevel]=uL[topLevel];
    steps=maxIter%steps;
    for(int i=topLevel-1;i>=0;i--) { 
      // determine top level for the rest
      int rTopLevel=0;
      int rsteps=1;
      for(int j=0;j<=i;j++) { 
        rsteps*=aL[j];
        if (rsteps<steps) 
          rTopLevel++;
        else
          break; 
      }
      rsteps/=aL[rTopLevel];
      ufL[rTopLevel]=steps/rsteps;
      steps%=rsteps;
    }
    for(int i=0;i<levels;i++) { 
      std::cout << "level " << i << " aL: " << aL[i] << " uL: " << uL[i] << " ufL: "  << ufL[i] << std::endl; 
    }
  }

  void operator++() { 
    for(changedLevel=0;changedLevel<topLevel;changedLevel++) { 
      if (iL[changedLevel]==uL[changedLevel])
        iL[changedLevel]=1;
      else { 
        il[changedLevel]++;
        break;
      }
    }
  }
    
  void operator--() { 
    for(changedLevel=0;changedLevel<levels;changedLevel++) { 
      if (iL[changedLevel]==1) {
        iL[changedLevel]=uL[iLc];
        for (int i=changedLevel;i<levels; i++) { 
          
        } 
      }
      else { 
        il[changedLevel]--;
        break;
      }
    }
  }


};
    
void cpscheme(int iter,
              bool adjoint,
              CP& cp) { 
   int i; 
   if (!adjoint) { 
     // increment a level and remember which level changes:  
     int iLc;  // the level that changes: 
     for(iLc=0;iLc<levels;iLc++) { 
       if (iL[iLc]==uL[iLc])
       iL[iLc]=1;
       else { 
        il[iLc]++;
        break;
       }
     }
     if (iLc==cpLevel) { 
       // do checkpoint
     }
   }
   else { // do the adjoint
     // decrement a level and remember which level changes:  
     int iLc;  // the level that changes: 
     for(iLc=0;iLc<levels;iLc++) { 
       if (iL[iLc]==1)
        iL[iLc]=ul;
       else { 
        il[iLc]++;
        break;
       }
     }
     if (iLc==cpLevel) { 
       // do checkpoint
     }
   } 
 }

int main(void) { 
  CP cp;
  std::cout << "maxIter: "; 
  std::cin >> cp.maxIter; 
  cp.aL[0]=3;
  cp.aL[1]=4;
  cp.aL[2]=5;
  cp.aL[3]=6;
  cp.init();
  
   for (int i=0;i<maxIter;i++) { 
     cpscheme(i, cp); 
   }
}

1	utke	1.1	#include <iostream>
2
3			class CP {
4			public:
5			static const int levels=4; // the number of levels
6			int maxIter; // maximal iteration
7			int aL[levels]; // allowed per level
8			int uL[levels]; // used per level
9			int iL[levels]; // current iteration per level
10			int changedLevel; // level changed due to increment or decrement
11			int topLevel; // the top Level
12			int cpLevel; // current checkpoint level
13			int tapeLevel; // current taping level
14			int adjointLevel; // current adjoint level
15
16			CP() {
17			maxIter=0;
18			for (int i=0;i<levels;i++) {
19			iL[i]=aL[i]=uL[i]=ufL[i]=0;
20			}
21			topLevel=0;
22			cpLevel=0;
23			tapeLevel=0;
24			adjointLevel=0;
25			}
26
27			void init(){
28			// determine top level
29			topLevel=0;
30			int steps=1;
31			for(int i=0;i<levels;i++) {
32			steps*=aL[i];
33			if (steps<maxIter)
34			topLevel++;
35			else
36			break;
37			}
38			if (topLevel>=levels) {
39			std::cerr << "insufficient checkpoints" << std::endl;
40			}
41			for(int i=0;i<topLevel;i++) {
42			iL[i]=1;
43			}
44			// determine uses:
45			steps/=aL[topLevel];
46			uL[topLevel]=1+maxIter/steps;
47			for(int i=topLevel-1;i>=0;i--) {
48			uL[i]=aL[i];
49			}
50			// determine final uses:
51			ufL[topLevel]=uL[topLevel];
52			steps=maxIter%steps;
53			for(int i=topLevel-1;i>=0;i--) {
54			// determine top level for the rest
55			int rTopLevel=0;
56			int rsteps=1;
57			for(int j=0;j<=i;j++) {
58			rsteps*=aL[j];
59			if (rsteps<steps)
60			rTopLevel++;
61			else
62			break;
63			}
64			rsteps/=aL[rTopLevel];
65			ufL[rTopLevel]=steps/rsteps;
66			steps%=rsteps;
67			}
68			for(int i=0;i<levels;i++) {
69			std::cout << "level " << i << " aL: " << aL[i] << " uL: " << uL[i] << " ufL: " << ufL[i] << std::endl;
70			}
71			}
72
73			void operator++() {
74			for(changedLevel=0;changedLevel<topLevel;changedLevel++) {
75			if (iL[changedLevel]==uL[changedLevel])
76			iL[changedLevel]=1;
77			else {
78			il[changedLevel]++;
79			break;
80			}
81			}
82			}
83
84			void operator--() {
85			for(changedLevel=0;changedLevel<levels;changedLevel++) {
86			if (iL[changedLevel]==1) {
87			iL[changedLevel]=uL[iLc];
88			for (int i=changedLevel;i<levels; i++) {
89
90			}
91			}
92			else {
93			il[changedLevel]--;
94			break;
95			}
96			}
97			}
98
99
100			};
101
102			void cpscheme(int iter,
103			bool adjoint,
104			CP& cp) {
105			int i;
106			if (!adjoint) {
107			// increment a level and remember which level changes:
108			int iLc; // the level that changes:
109			for(iLc=0;iLc<levels;iLc++) {
110			if (iL[iLc]==uL[iLc])
111			iL[iLc]=1;
112			else {
113			il[iLc]++;
114			break;
115			}
116			}
117			if (iLc==cpLevel) {
118			// do checkpoint
119			}
120			}
121			else { // do the adjoint
122			// decrement a level and remember which level changes:
123			int iLc; // the level that changes:
124			for(iLc=0;iLc<levels;iLc++) {
125			if (iL[iLc]==1)
126			iL[iLc]=ul;
127			else {
128			il[iLc]++;
129			break;
130			}
131			}
132			if (iLc==cpLevel) {
133			// do checkpoint
134			}
135			}
136			}
137
138			int main(void) {
139			CP cp;
140			std::cout << "maxIter: ";
141			std::cin >> cp.maxIter;
142			cp.aL[0]=3;
143			cp.aL[1]=4;
144			cp.aL[2]=5;
145			cp.aL[3]=6;
146			cp.init();
147
148			for (int i=0;i<maxIter;i++) {
149			cpscheme(i, cp);
150			}
151			}
152