1 /*
2 * Copyright (C) 1989-1991 Yale University
3 *
4 * This work is distributed in the hope that it will be useful; you can
5 * redistribute it and/or modify it under the terms of the
6 * GNU General Public License as published by the Free Software Foundation;
7 * either version 2 of the License,
8 * or any later version, on the following conditions:
9 *
10 * (a) YALE MAKES NO, AND EXPRESSLY DISCLAIMS
11 * ALL, REPRESENTATIONS OR WARRANTIES THAT THE MANUFACTURE, USE, PRACTICE,
12 * SALE OR
13 * OTHER DISPOSAL OF THE SOFTWARE DOES NOT OR WILL NOT INFRINGE UPON ANY
14 * PATENT OR
15 * OTHER RIGHTS NOT VESTED IN YALE.
16 *
17 * (b) YALE MAKES NO, AND EXPRESSLY DISCLAIMS ALL, REPRESENTATIONS AND
18 * WARRANTIES
19 * WHATSOEVER WITH RESPECT TO THE SOFTWARE, EITHER EXPRESS OR IMPLIED,
20 * INCLUDING,
21 * BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A
22 * PARTICULAR
23 * PURPOSE.
24 *
25 * (c) LICENSEE SHALL MAKE NO STATEMENTS, REPRESENTATION OR WARRANTIES
26 * WHATSOEVER TO
27 * ANY THIRD PARTIES THAT ARE INCONSISTENT WITH THE DISCLAIMERS BY YALE IN
28 * ARTICLE
29 * (a) AND (b) above.
30 *
31 * (d) IN NO EVENT SHALL YALE, OR ITS TRUSTEES, DIRECTORS, OFFICERS,
32 * EMPLOYEES AND
33 * AFFILIATES BE LIABLE FOR DAMAGES OF ANY KIND, INCLUDING ECONOMIC DAMAGE OR
34 * INJURY TO PROPERTY AND LOST PROFITS, REGARDLESS OF WHETHER YALE SHALL BE
35 * ADVISED, SHALL HAVE OTHER REASON TO KNOW, OR IN FACT SHALL KNOW OF THE
36 * POSSIBILITY OF THE FOREGOING.
37 *
38 */
39
40 /* -----------------------------------------------------------------
41 FILE: urcost.c
42 DESCRIPTION:update global routing cost.
43 CONTENTS: urcost( segptr )
44 SEGBOXPTR segptr ;
45 DATE: Mar 27, 1989
46 REVISIONS: Tue Mar 19 16:22:56 CST 1991 - fixed crash when
47 there are no routing tracks in a channel.
48 ----------------------------------------------------------------- */
49
50 #include "standard.h"
51 #include "groute.h"
52 #include <yalecad/debug.h>
53
urcost(SEGBOXPTR segptr)54 int urcost(SEGBOXPTR segptr )
55 {
56
57 CHANGRDPTR aptr1 , aptr2 , bptr1 , bptr2 , ptr ;
58 DENSITYPTR denptr , headptr ;
59 INT penalty , check ;
60 INT x , achannel , bchannel , aMaxVal , bMaxVal ;
61 INT maxaa , maxbb , pin1 , pin2 ;
62 INT aoutside , binside ;
63 INT ax1 , ax2 , bx1 , bx2 ;
64 INT track ;
65
66 penalty = 0 ;
67 pin1 = segptr->pin1ptr->terminal ;
68 pin2 = segptr->pin2ptr->terminal ;
69 if( segptr->switchvalue == swUP ) {
70 aptr1 = TgridG[pin1]->up ;
71 aptr2 = TgridG[pin2]->up ;
72 bptr1 = TgridG[pin1]->down ;
73 bptr2 = TgridG[pin2]->down ;
74 bchannel = segptr->pin1ptr->row ;
75 achannel = bchannel + 1 ;
76 } else {
77 aptr1 = TgridG[pin1]->down ;
78 aptr2 = TgridG[pin2]->down ;
79 bptr1 = TgridG[pin1]->up ;
80 bptr2 = TgridG[pin2]->up ;
81 achannel = segptr->pin1ptr->row ;
82 bchannel = achannel + 1 ;
83 }
84
85 aMaxVal = maxTrackG[achannel] ;
86 bMaxVal = maxTrackG[bchannel] ;
87 ax1 = aptr1->netptr->xpos ;
88 ax2 = aptr2->netptr->xpos ;
89 bx1 = bptr1->netptr->xpos ;
90 bx2 = bptr2->netptr->xpos ;
91
92 aoutside = 0 ;
93 denptr = DboxHeadG[ achannel ][ aMaxVal ]->next ;
94 for( ; denptr != DENSENULL ; denptr = denptr->next ) {
95 x = denptr->grdptr->netptr->xpos ;
96 if( !( ax1 <= x && ax2 >= x ) || denptr->grdptr->cross > 1 ) {
97 aoutside = 1 ;
98 break ;
99 }
100 }
101 if( aoutside == 0 ) {
102 penalty-- ;
103 }
104
105 binside = 0 ;
106 denptr = DboxHeadG[ bchannel ][ bMaxVal ]->next ;
107 for( ; denptr != DENSENULL ; denptr = denptr->next ) {
108 x = denptr->grdptr->netptr->xpos ;
109 if( bx1 <= x && bx2 >= x && denptr->grdptr->cross == 0 ) {
110 binside = 1 ;
111 break ;
112 }
113 }
114 if( binside == 1 ) {
115 penalty++ ;
116 }
117
118 while( aptr1->prevgrd ) {
119 if( aptr1->prevgrd->netptr->xpos == ax1 ) {
120 aptr1 = aptr1->prevgrd ;
121 } else {
122 break ;
123 }
124 }
125 while( aptr2->nextgrd ) {
126 if( aptr2->nextgrd->netptr->xpos == ax2 ) {
127 aptr2 = aptr2->nextgrd ;
128 } else {
129 break ;
130 }
131 }
132 while( bptr1->prevgrd ) {
133 if( bptr1->prevgrd->netptr->xpos == bx1 ) {
134 bptr1 = bptr1->prevgrd ;
135 } else {
136 break ;
137 }
138 }
139 while( bptr2->nextgrd ) {
140 if( bptr2->nextgrd->netptr->xpos == bx2 ) {
141 bptr2 = bptr2->nextgrd ;
142 } else {
143 break ;
144 }
145 }
146 aptr2 = aptr2->nextgrd ;
147 bptr2 = bptr2->nextgrd ;
148 if( penalty == 0 ) {
149 if( binside == 1 && aoutside == 0 ) {
150 /* check = (aMaxVal - 1) - (bMaxVal + 1) ; */
151 check = ABS(aMaxVal - bMaxVal - 2) - ABS(bMaxVal - aMaxVal) ;
152 } else {
153 maxaa = 0 ;
154 maxbb = 0 ;
155 for( ptr = aptr1 ; ptr != aptr2 ; ptr = ptr->nextgrd ) {
156 if( ptr->tracks > maxaa ) {
157 maxaa = ptr->tracks ;
158 }
159 }
160 for( ptr = bptr1 ; ptr != bptr2 ; ptr = ptr->nextgrd ) {
161 if( ptr->tracks > maxbb ) {
162 maxbb = ptr->tracks ;
163 }
164 }
165 /* maxaa = aMaxVal - maxaa + 1 ; */
166 /* maxbb = bMaxVal - maxbb - 1 ; */
167 /* check = maxaa - maxbb ; */
168 check = ABS(aMaxVal - maxaa - bMaxVal + maxbb + 2) -
169 ABS(aMaxVal - maxaa - bMaxVal + maxbb) ;
170 }
171 } else {
172 check = penalty ;
173 }
174
175 if( check <= 0 ) {
176 for( ptr = aptr1 ; ptr != aptr2 ; ptr = ptr->nextgrd ) {
177 denptr = ptr->dptr ;
178 if( ptr->cross == 1 ) {
179 ptr->cross = 0 ;
180 if( denptr->next != DENSENULL ) {
181 denptr->next->back = denptr->back ;
182 }
183 denptr->back->next = denptr->next ;
184 track = --(ptr->tracks) ;
185 if( track == -1 ){
186 track = 0 ;
187 D( "twsc/urcost",
188 fprintf( stderr, " track less than 1 reset to 0\n" ) ;
189 ) ;
190 }
191
192 headptr = DboxHeadG[ achannel ][ track ]->next ;
193 if( headptr != DENSENULL ) {
194 DboxHeadG[ achannel ][ track ]->next = denptr ;
195 denptr->next = headptr ;
196 headptr->back = denptr ;
197 denptr->back = DboxHeadG[ achannel ][ track ] ;
198 } else {
199 DboxHeadG[ achannel ][ track ]->next = denptr ;
200 denptr->next = DENSENULL ;
201 denptr->back = DboxHeadG[ achannel ][ track ];
202 }
203 } else {
204 ptr->cross-- ;
205 }
206 }
207 if( aoutside == 0 ) {
208 maxTrackG[achannel]-- ;
209 }
210 for( ptr = bptr1 ; ptr != bptr2 ; ptr = ptr->nextgrd ) {
211 denptr = ptr->dptr ;
212 if( ptr->cross == 0 ) {
213 ptr->cross = 1 ;
214 if( denptr->next != DENSENULL ) {
215 denptr->next->back = denptr->back ;
216 }
217 denptr->back->next = denptr->next ;
218 track = ++(ptr->tracks) ;
219
220 headptr = DboxHeadG[ bchannel ][ track ]->next ;
221 if( headptr != DENSENULL ) {
222 DboxHeadG[ bchannel ][ track ]->next = denptr ;
223 denptr->next = headptr ;
224 headptr->back = denptr ;
225 denptr->back = DboxHeadG[ bchannel ][ track ] ;
226 } else {
227 DboxHeadG[ bchannel ][ track ]->next = denptr ;
228 denptr->next = DENSENULL ;
229 denptr->back = DboxHeadG[ bchannel ][ track ];
230 }
231 } else {
232 ptr->cross++ ;
233 }
234 }
235 if( binside == 1 ) {
236 maxTrackG[bchannel]++ ;
237 }
238 if( segptr->switchvalue == swUP ) {
239 segptr->switchvalue = swDOWN ;
240 } else {
241 segptr->switchvalue = swUP ;
242 }
243
244 tracksG += penalty ;
245 return (1) ;
246 } else {
247 return (0) ;
248 }
249 }
250