3D-ICE 3.0.0
dimensions.c
1/******************************************************************************
2 * This file is part of 3D-ICE, version 3.1.0 . *
3 * *
4 * 3D-ICE is free software: you can redistribute it and/or modify it under *
5 * the terms of the GNU General Public License as published by the Free *
6 * Software Foundation, either version 3 of the License, or any later *
7 * version. *
8 * *
9 * 3D-ICE is distributed in the hope that it will be useful, but WITHOUT *
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or *
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for *
12 * more details. *
13 * *
14 * You should have received a copy of the GNU General Public License along *
15 * with 3D-ICE. If not, see <http://www.gnu.org/licenses/>. *
16 * *
17 * Copyright (C) 2021 *
18 * Embedded Systems Laboratory - Ecole Polytechnique Federale de Lausanne *
19 * All Rights Reserved. *
20 * *
21 * Authors: Arvind Sridhar Alessandro Vincenzi *
22 * Giseong Bak Martino Ruggiero *
23 * Thomas Brunschwiler Eder Zulian *
24 * Federico Terraneo Darong Huang *
25 * Luis Costero Marina Zapater *
26 * David Atienza *
27 * *
28 * For any comment, suggestion or request about 3D-ICE, please register and *
29 * write to the mailing list (see http://listes.epfl.ch/doc.cgi?liste=3d-ice) *
30 * Any usage of 3D-ICE for research, commercial or other purposes must be *
31 * properly acknowledged in the resulting products or publications. *
32 * *
33 * EPFL-STI-IEL-ESL Mail : 3d-ice@listes.epfl.ch *
34 * Batiment ELG, ELG 130 (SUBSCRIPTION IS NECESSARY) *
35 * Station 11 *
36 * 1015 Lausanne, Switzerland Url : http://esl.epfl.ch/3d-ice *
37 ******************************************************************************/
38
39#include <stdlib.h> // For the memory functions malloc/free
40#include <string.h> // For the memory function memcpy
41#include <assert.h>
42
43#include "dimensions.h"
44#include "heat_sink.h"
45
46/******************************************************************************/
47
49{
50 celld->FirstWallLength = (CellDimension_t) 0.0 ;
51 celld->LastWallLength = (CellDimension_t) 0.0 ;
52 celld->WallLength = (CellDimension_t) 0.0 ;
53 celld->ChannelLength = (CellDimension_t) 0.0 ;
54 celld->Width = (CellDimension_t) 0.0 ;
55 celld->NHeights = (Quantity_t) 0u ;
56 celld->Heights = NULL ;
57}
58
59/******************************************************************************/
60
62{
64
65 dst->FirstWallLength = src->FirstWallLength ;
66 dst->LastWallLength = src->LastWallLength ;
67 dst->WallLength = src->WallLength ;
68 dst->ChannelLength = src->ChannelLength ;
69 dst->Width = src->Width ;
70 dst->NHeights = src->NHeights ;
71
72 if (src->Heights == NULL)
73 {
74 dst->Heights = NULL ;
75
76 return ;
77 }
78
79 dst->Heights = (CellDimension_t *)
80
81 malloc (src->NHeights * sizeof (CellDimension_t)) ;
82
83 if (dst->Heights == NULL)
84 {
85 fprintf (stderr, "Malloc heights error\n") ;
86
87 return ;
88 }
89
90 memcpy (dst->Heights, src->Heights,
91 src->NHeights * sizeof (CellDimension_t) ) ;
92}
93
94/******************************************************************************/
95
97{
98 if (celld->Heights != NULL)
99
100 free (celld->Heights) ;
101
102 cell_dimensions_init (celld) ;
103}
104
105/******************************************************************************/
106/******************************************************************************/
107/******************************************************************************/
108
110{
111 gridd->NLayers = (CellIndex_t) 0u ;
112 gridd->NRows = (CellIndex_t) 0u ;
113 gridd->NColumns = (CellIndex_t) 0u ;
114 gridd->NCells = (CellIndex_t) 0u ;
115 gridd->NConnections = (CellIndex_t) 0u ;
116}
117
118/******************************************************************************/
119
121{
123
124 dst->NLayers = src->NLayers ;
125 dst->NRows = src->NRows ;
126 dst->NColumns = src->NColumns ;
127 dst->NCells = src->NCells ;
128 dst->NConnections = src->NConnections ;
129}
130
131/******************************************************************************/
132
134{
135 // Nothing to do ...
136
137 grid_dimensions_init (gridd) ;
138}
139
140/******************************************************************************/
141/******************************************************************************/
142/******************************************************************************/
143
145{
146 chipd->Length = (CellDimension_t) 0.0 ;
147 chipd->Width = (CellDimension_t) 0.0 ;
148}
149
150/******************************************************************************/
151
153{
155
156 dst->Length = src->Length ;
157 dst->Width = src->Width ;
158}
159
160/******************************************************************************/
161
163{
164 // Nothing to do ...
165
166 chip_dimensions_init (chipd) ;
167}
168
169/******************************************************************************/
170/******************************************************************************/
171/******************************************************************************/
172
174{
175 cell_dimensions_init (&dimensions->Cell) ;
176 grid_dimensions_init (&dimensions->Grid) ;
177 chip_dimensions_init (&dimensions->Chip) ;
178
179 dimensions->NonUniform = 0;
180 dimensions->Discr_X = 0;
181 dimensions->Discr_Y = 0;
182
183 non_uniform_cell_list_init(&dimensions->Cell_list);
184 connection_list_init(&dimensions->connections_list);
185}
186
187/******************************************************************************/
188
190{
191 dimensions_destroy (dst) ;
192 dst->NonUniform = src->NonUniform;
193 dst->Discr_X = src->Discr_X;
194 dst->Discr_Y = src->Discr_Y;
195 cell_dimensions_copy (&dst->Cell, &src->Cell) ;
196 grid_dimensions_copy (&dst->Grid, &src->Grid) ;
197 chip_dimensions_copy (&dst->Chip, &src->Chip) ;
198
199 non_uniform_cell_list_copy(&dst->Cell_list, &src->Cell_list) ;
200 connection_list_copy(&dst->connections_list, &src->connections_list) ;
201}
202
203/******************************************************************************/
204
206{
207 cell_dimensions_destroy (&dimensions->Cell) ;
208 grid_dimensions_destroy (&dimensions->Grid) ;
209 chip_dimensions_destroy (&dimensions->Chip) ;
210
211 non_uniform_cell_list_destroy(&dimensions->Cell_list);
212 connection_list_destroy(&dimensions->connections_list);
213
214 dimensions_init (dimensions) ;
215}
216
217/******************************************************************************/
218
220{
221 Dimensions_t *dimensions = (Dimensions_t *) malloc (sizeof(Dimensions_t)) ;
222
223 if (dimensions != NULL)
224
225 dimensions_init (dimensions) ;
226
227 return dimensions ;
228}
229
230/******************************************************************************/
231
233{
234 if (dimensions == NULL)
235
236 return NULL ;
237
238 Dimensions_t *newd = dimensions_calloc ( ) ;
239
240 if (newd != NULL)
241
242 dimensions_copy (newd, dimensions) ;
243
244 return newd ;
245}
246
247/******************************************************************************/
248
250{
251 if (dimensions == NULL)
252
253 return ;
254
255 dimensions_destroy (dimensions) ;
256
257 free (dimensions) ;
258}
259
260/******************************************************************************/
261
263(
264 Dimensions_t *dimensions,
265 FILE *stream,
266 String_t prefix
267)
268{
269 fprintf (stream,
270 "%sdimensions : \n",
271 prefix) ;
272
273 fprintf (stream,
274 "%s chip length %7.1f , width %7.1f ;\n",
275 prefix, dimensions->Chip.Length, dimensions->Chip.Width) ;
276
277 fprintf (stream,
278 "%s cell length %7.1f , width %7.1f ;\n",
279 prefix, dimensions->Cell.WallLength, dimensions->Cell.Width) ;
280}
281
282/******************************************************************************/
283
284void print_axes (Dimensions_t *dimensions)
285{
286 FILE *file = fopen ("xaxis.txt", "w") ;
287
288 if (file == NULL)
289 {
290 fprintf (stderr, "Cannot create text file for x axis\n") ;
291 return ;
292 }
293
294 CellIndex_t column ;
295
296 for (column = first_column (dimensions) ; column <= last_column (dimensions) ; column++)
297
298 fprintf (file, "%5.2f\n", get_cell_center_x (dimensions, column)) ;
299
300 fclose (file) ;
301
302 file = fopen ("yaxis.txt", "w") ;
303
304 if (file == NULL)
305 {
306 fprintf (stderr, "Cannot create text file for y axis\n") ;
307 return ;
308 }
309
310 CellIndex_t row ;
311
312 for (row = first_row (dimensions) ; row <= last_row (dimensions) ; row++)
313
314 fprintf (file, "%5.2f\n", get_cell_center_y (dimensions, row)) ;
315
316 fclose (file) ;
317}
318
319/******************************************************************************/
320
322(
323 Dimensions_t *dimensions,
324 Quantity_t num_channels,
325 ChannelModel_t channel_model,
326 HeatSink_t *topSink
327)
328{
329 CellIndex_t nlayers = dimensions->Grid.NLayers ;
330 CellIndex_t nrows = dimensions->Grid.NRows ;
331 CellIndex_t ncolumns = dimensions->Grid.NColumns ;
332
333 CellIndex_t nlayers_for_channel = num_channels * NUM_LAYERS_CHANNEL_2RM ;
334 CellIndex_t nlayers_except_channel = nlayers - nlayers_for_channel ;
335
336 CellIndex_t tmp = 2u ;
337
338 switch (channel_model)
339 {
342 {
343 dimensions->Grid.NConnections =
344
345 // All Normal Cells
346
347 // number of coefficients in the diagonal
348 nlayers * nrows * ncolumns
349 +
350 // number of coefficients bottom <-> top
351 2 * (nlayers - 1) * nrows * ncolumns
352 +
353 // Number of coefficients North <-> South
354 2 * nlayers * (nrows - 1) * ncolumns
355 +
356 // Number of coefficients East <-> West
357 2 * nlayers * nrows * (ncolumns - 1) ;
358
359 break ;
360 }
362
363 tmp += 2 ;
364 // fallthrough
365
368 {
369 dimensions->Grid.NConnections =
370
371 // For Normal Cells
372
373 // Number of coefficients in the diagonal
374 nlayers_except_channel * nrows * ncolumns
375 +
376 // Number of coefficients Bottom <-> Top
377 2 * nlayers_except_channel * nrows * ncolumns
378 +
379 // Number of coefficients North <-> South
380 2 * nlayers_except_channel * (nrows - 1) * ncolumns
381 +
382 // Number of coefficients East <-> West
383 2 * nlayers_except_channel * nrows * (ncolumns - 1)
384 +
385
386 // For Channel Cells
387
388 // Number of coefficients in the diagonal
389 nlayers_for_channel * nrows * ncolumns
390 +
391 // Number of coefficients Bottom <-> Top
392 2 * (nlayers_for_channel + num_channels) * nrows * ncolumns
393 +
394 // Number of coefficients North <-> South
395 tmp * num_channels * (nrows - 1) * ncolumns
396 +
397 // Number of coefficients East <-> West
398 0
399 ;
400
401 break ;
402 }
403 default :
404
405 fprintf (stderr, "Error: unknown channel model %d\n", channel_model) ;
406 }
407
408 if(topSink && topSink->SinkModel == TDICE_HEATSINK_TOP_PLUGGABLE)
409 {
410 // Add the heat spreader, which has a different size and is thus not
411 // counted among the layers
412 dimensions->Grid.NConnections +=
413
414 // number of coefficients in the diagonal
415 topSink->NRows * topSink->NColumns
416 +
417 // Number of coefficients North <-> South
418 2 * (topSink->NRows - 1) * topSink->NColumns
419 +
420 // Number of coefficients East <-> West
421 2 * topSink->NRows * (topSink->NColumns - 1) ;
422
423
424 //Then add the connections between the last layer of the stack and
425 //the middle of the spreader
426 dimensions->Grid.NConnections +=
427
428 // number of coefficients bottom <-> top
429 2 * nrows * ncolumns ;
430 }
431}
432
433/******************************************************************************/
434
435CellIndex_t first_row (Dimensions_t __attribute__ ((unused)) *dimensions)
436{
437 return 0u ;
438}
439
440/******************************************************************************/
441
443{
444 return get_number_of_rows (dimensions) - 1 ;
445}
446
447/******************************************************************************/
448
449CellIndex_t first_column (Dimensions_t __attribute__ ((unused)) *dimensions)
450{
451 return 0u ;
452}
453
454/******************************************************************************/
455
457{
458 return get_number_of_columns (dimensions) - 1 ;
459}
460
461/******************************************************************************/
462
463CellIndex_t first_layer (Dimensions_t __attribute__ ((unused)) *dimensions)
464{
465 return 0u ;
466}
467
468/******************************************************************************/
469
471{
472 return get_number_of_layers (dimensions) - 1 ;
473}
474
475/******************************************************************************/
476
478(
479 Dimensions_t *dimensions,
480 CellIndex_t column_index
481)
482{
483 // column_index < 0 not tested since CellIndex_t is unsigned
484
485 if (column_index > last_column (dimensions))
486 {
487 fprintf (stderr,
488 "ERROR: column index %d is out of range\n", column_index) ;
489
490 return 0.0 ;
491 }
492
493 if (column_index == first_column (dimensions))
494
495 return dimensions->Cell.FirstWallLength ;
496
497 else if (column_index == last_column (dimensions))
498
499 return dimensions->Cell.LastWallLength ;
500
501 else
502
503 if (column_index & 1)
504
505 return dimensions->Cell.ChannelLength ;
506
507 else
508
509 return dimensions->Cell.WallLength ;
510}
511
512/******************************************************************************/
513
515(
516 Dimensions_t *dimensions,
517 CellIndex_t row_index
518)
519{
520 // column_index < 0 not tested since CellIndex_t is unsigned
521
522 if (row_index > last_row (dimensions))
523 {
524 fprintf (stderr,
525 "ERROR: row index %d is out of range\n", row_index) ;
526
527 return 0.0 ;
528 }
529
530 return dimensions->Cell.Width ;
531}
532
533/******************************************************************************/
534
536(
537 Dimensions_t *dimensions,
538 CellIndex_t layer_index
539)
540{
541 if (dimensions->Cell.Heights == NULL)
542 {
543 fprintf (stderr, "ERROR: vector of heigths does not exist in memory\n") ;
544
545 return 0.0 ;
546 }
547
548 // layer_index < 0 not tested since CellIndex_t is unsigned
549
550 if (layer_index > dimensions->Cell.NHeights)
551 {
552 fprintf (stderr,
553 "ERROR: layer index %d is out of range\n", layer_index) ;
554
555 return 0.0 ;
556 }
557
558 return dimensions->Cell.Heights [ layer_index ] ;
559}
560
561/******************************************************************************/
562
564(
565 Dimensions_t *dimensions,
566 CellIndex_t column_index
567)
568{
569 if (column_index == first_column (dimensions))
570
571 return dimensions->Cell.FirstWallLength / 2.0 ;
572
573 else if (column_index == last_column (dimensions))
574
575 return (dimensions->Cell.FirstWallLength )
576 + (dimensions->Cell.ChannelLength / 2.0) * (column_index )
577 + (dimensions->Cell.WallLength / 2.0) * (column_index - 2)
578 + (dimensions->Cell.LastWallLength / 2.0) ;
579
580 else
581
582 return (dimensions->Cell.FirstWallLength )
583 + (dimensions->Cell.ChannelLength / 2.0) * (column_index )
584 + (dimensions->Cell.WallLength / 2.0) * (column_index - 1) ;
585}
586
587/******************************************************************************/
588
590(
591 Dimensions_t *dimensions,
592 CellIndex_t row_index
593)
594{
595 return dimensions->Cell.Width / 2.0
596 + dimensions->Cell.Width * row_index ;
597}
598
599/******************************************************************************/
600
602(
603 Dimensions_t *dimensions,
604 CellIndex_t column_index
605)
606{
607 if (column_index == first_column (dimensions))
608
609 return 0.0 ;
610
611 else
612
613 return (dimensions->Cell.FirstWallLength)
614 + (dimensions->Cell.ChannelLength ) * ((column_index ) / 2u)
615 + (dimensions->Cell.WallLength ) * ((column_index - 1) / 2u) ;
616}
617
618/******************************************************************************/
619
621(
622 Dimensions_t *dimensions,
623 CellIndex_t row_index
624)
625{
626 return dimensions->Cell.Width * row_index ;
627}
628
629/******************************************************************************/
630
632{
633 return dimensions->Grid.NLayers ;
634}
635
636/******************************************************************************/
637
639{
640 return dimensions->Grid.NRows ;
641}
642
643/******************************************************************************/
644
646{
647 return dimensions->Grid.NColumns ;
648}
649
650/******************************************************************************/
651
653{
654 return dimensions->Grid.NCells ;
655}
656
657/******************************************************************************/
658
660{
661 return dimensions->Grid.NConnections ;
662}
663
664/******************************************************************************/
665
667{
668 return dimensions->Grid.NRows * dimensions->Grid.NColumns ;
669}
670
671/******************************************************************************/
672
674(
675 Dimensions_t *dimensions,
676 CellIndex_t row_index,
677 CellIndex_t column_index
678)
679{
680 return row_index * get_number_of_columns (dimensions) + column_index ;
681}
682
683/******************************************************************************/
684
686(
687 Dimensions_t *dimensions,
688 CellIndex_t layer_index,
689 CellIndex_t row_index,
690 CellIndex_t column_index
691)
692{
693 return layer_index * get_layer_area (dimensions)
694 + get_cell_offset_in_layer (dimensions, row_index, column_index) ;
695}
696
697/******************************************************************************/
698
700{
701 return dimensions->Chip.Length ;
702}
703
704/******************************************************************************/
705
707{
708 return dimensions->Chip.Width ;
709}
710
711/******************************************************************************/
712
714{
715 return get_chip_length (dimensions) * get_chip_width (dimensions) ;
716}
717
718/******************************************************************************/
719
721(
722 Dimensions_t *dimensions,
723 HeatSink_t *hsink,
724 CellIndex_t row_index,
725 CellIndex_t column_index
726)
727{
728 assert(hsink->SinkModel == TDICE_HEATSINK_TOP_PLUGGABLE);
729
730 if(dimensions->NonUniform == 1) //recaculate spreder offset in the non-uniform scenario
731 {
732 return dimensions->Grid.NCells - hsink->NColumns*hsink->NRows;
733 }
734 else
735 {
736 return ( get_number_of_layers (dimensions)
737 * get_number_of_rows (dimensions)
738 * get_number_of_columns (dimensions))
739 + row_index * hsink->NColumns + column_index;
740 }
741
742}
743
744/******************************************************************************/
745
747(
748 Dimensions_t *dimensions,
749 HeatSink_t *hsink,
750 CellIndex_t row_index,
751 CellIndex_t column_index
752)
753{
755 dimensions,
756 hsink,
757 row_index + hsink->NumRowsBorder,
758 column_index + hsink->NumColumnsBorder);
759}
760
761/******************************************************************************/
762
764(
765 Dimensions_t *dimensions,
766 HeatSink_t *hsink,
767 CellIndex_t row_index,
768 CellIndex_t column_index
769)
770{
771 assert(hsink->SinkModel == TDICE_HEATSINK_TOP_PLUGGABLE);
772
773 if( row_index >= hsink->NumRowsBorder
774 && row_index < hsink->NumRowsBorder + get_number_of_rows (dimensions)
775 && column_index >= hsink->NumColumnsBorder
776 && column_index < hsink->NumColumnsBorder + get_number_of_columns (dimensions))
777 return true;
778 else
779 return false;
780}
781
783(
784 Dimensions_t *dimensions,
785 HeatSink_t *hsink,
786 CellIndex_t layer_index,
787 CellIndex_t row_index,
788 CellIndex_t column_index
789)
790{
791 assert(has_layer_underneath(dimensions, hsink, row_index, column_index));
792
794 dimensions,
795 layer_index,
796 row_index - hsink->NumRowsBorder,
797 column_index - hsink->NumColumnsBorder);
798}
799
800/******************************************************************************/
801
void cell_dimensions_copy(CellDimensions_t *dst, CellDimensions_t *src)
Definition: dimensions.c:61
void dimensions_destroy(Dimensions_t *dimensions)
Definition: dimensions.c:205
ChipDimension_t get_chip_length(Dimensions_t *dimensions)
Definition: dimensions.c:699
CellIndex_t get_number_of_connections(Dimensions_t *dimensions)
Definition: dimensions.c:659
CellDimension_t get_cell_height(Dimensions_t *dimensions, CellIndex_t layer_index)
Definition: dimensions.c:536
void cell_dimensions_init(CellDimensions_t *celld)
Definition: dimensions.c:48
ChipDimension_t get_cell_location_y(Dimensions_t *dimensions, CellIndex_t row_index)
Definition: dimensions.c:621
void grid_dimensions_init(GridDimensions_t *gridd)
Definition: dimensions.c:109
CellIndex_t get_number_of_layers(Dimensions_t *dimensions)
Definition: dimensions.c:631
ChipDimension_t get_chip_width(Dimensions_t *dimensions)
Definition: dimensions.c:706
ChipDimension_t get_cell_location_x(Dimensions_t *dimensions, CellIndex_t column_index)
Definition: dimensions.c:602
void dimensions_print(Dimensions_t *dimensions, FILE *stream, String_t prefix)
Definition: dimensions.c:263
CellIndex_t get_layer_cell_offset_from_spreader_coordinates(Dimensions_t *dimensions, struct HeatSink_t *hsink, CellIndex_t layer_index, CellIndex_t row_index, CellIndex_t column_index)
Definition: dimensions.c:783
void dimensions_init(Dimensions_t *dimensions)
Definition: dimensions.c:173
CellIndex_t get_cell_offset_in_stack(Dimensions_t *dimensions, CellIndex_t layer_index, CellIndex_t row_index, CellIndex_t column_index)
Definition: dimensions.c:686
CellIndex_t get_spreader_cell_offset(Dimensions_t *dimensions, struct HeatSink_t *hsink, CellIndex_t row_index, CellIndex_t column_index)
Definition: dimensions.c:721
CellIndex_t get_spreader_cell_offset_from_layer_coordinates(Dimensions_t *dimensions, struct HeatSink_t *hsink, CellIndex_t row_index, CellIndex_t column_index)
Definition: dimensions.c:747
void dimensions_free(Dimensions_t *dimensions)
Definition: dimensions.c:249
void grid_dimensions_copy(GridDimensions_t *dst, GridDimensions_t *src)
Definition: dimensions.c:120
CellDimension_t get_cell_length(Dimensions_t *dimensions, CellIndex_t column_index)
Definition: dimensions.c:478
CellDimension_t get_cell_width(Dimensions_t *dimensions, CellIndex_t row_index)
Definition: dimensions.c:515
void cell_dimensions_destroy(CellDimensions_t *celld)
Definition: dimensions.c:96
ChipDimension_t get_chip_area(Dimensions_t *dimensions)
Definition: dimensions.c:713
void chip_dimensions_init(ChipDimensions_t *chipd)
Definition: dimensions.c:144
Dimensions_t * dimensions_calloc(void)
Definition: dimensions.c:219
CellIndex_t last_column(Dimensions_t *dimensions)
Definition: dimensions.c:456
void dimensions_copy(Dimensions_t *dst, Dimensions_t *src)
Definition: dimensions.c:189
CellIndex_t get_cell_offset_in_layer(Dimensions_t *dimensions, CellIndex_t row_index, CellIndex_t column_index)
Definition: dimensions.c:674
void print_axes(Dimensions_t *dimensions)
Definition: dimensions.c:284
ChipDimension_t get_cell_center_x(Dimensions_t *dimensions, CellIndex_t column_index)
Definition: dimensions.c:564
void chip_dimensions_destroy(ChipDimensions_t *chipd)
Definition: dimensions.c:162
CellIndex_t get_number_of_cells(Dimensions_t *dimensions)
Definition: dimensions.c:652
void chip_dimensions_copy(ChipDimensions_t *dst, ChipDimensions_t *src)
Definition: dimensions.c:152
ChipDimension_t get_cell_center_y(Dimensions_t *dimensions, CellIndex_t row_index)
Definition: dimensions.c:590
void compute_number_of_connections(Dimensions_t *dimensions, Quantity_t num_channels, ChannelModel_t channel_model, struct HeatSink_t *topSink)
Definition: dimensions.c:322
CellIndex_t last_layer(Dimensions_t *dimensions)
Definition: dimensions.c:470
CellIndex_t get_number_of_rows(Dimensions_t *dimensions)
Definition: dimensions.c:638
bool has_layer_underneath(Dimensions_t *dimensions, struct HeatSink_t *hsink, CellIndex_t row_index, CellIndex_t column_index)
Definition: dimensions.c:764
CellIndex_t first_layer(Dimensions_t *dimensions)
CellIndex_t first_column(Dimensions_t *dimensions)
void grid_dimensions_destroy(GridDimensions_t *gridd)
Definition: dimensions.c:133
Dimensions_t * dimensions_clone(Dimensions_t *dimensions)
Definition: dimensions.c:232
CellIndex_t get_number_of_columns(Dimensions_t *dimensions)
Definition: dimensions.c:645
CellIndex_t get_layer_area(Dimensions_t *dimensions)
Definition: dimensions.c:666
CellIndex_t first_row(Dimensions_t *dimensions)
CellIndex_t last_row(Dimensions_t *dimensions)
Definition: dimensions.c:442
char * String_t
Definition: string_t.h:55
Structure that collects the dimensions of a thermal cell.
Definition: dimensions.h:80
CellDimension_t LastWallLength
Definition: dimensions.h:102
CellDimension_t * Heights
Definition: dimensions.h:115
CellDimension_t Width
Definition: dimensions.h:106
CellDimension_t ChannelLength
Definition: dimensions.h:96
CellDimension_t FirstWallLength
Definition: dimensions.h:85
CellDimension_t WallLength
Definition: dimensions.h:91
Quantity_t NHeights
Definition: dimensions.h:110
Structure that collects the main dimensions of the IC.
Definition: dimensions.h:255
ChipDimension_t Length
Definition: dimensions.h:258
ChipDimension_t Width
Definition: dimensions.h:262
Collections of all the structures that are needed for the thermal simulation.
Definition: dimensions.h:311
GridDimensions_t Grid
Definition: dimensions.h:318
ConnectionList_t connections_list
Definition: dimensions.h:340
CellIndex_t Discr_Y
Definition: dimensions.h:334
uint8_t NonUniform
Definition: dimensions.h:326
ChipDimensions_t Chip
Definition: dimensions.h:322
CellDimensions_t Cell
Definition: dimensions.h:314
Non_uniform_cellList_t Cell_list
Definition: dimensions.h:337
CellIndex_t Discr_X
Definition: dimensions.h:330
Structure that collects the dimensions of a 3d thermal grid of cells.
Definition: dimensions.h:165
CellIndex_t NCells
Definition: dimensions.h:203
CellIndex_t NLayers
Definition: dimensions.h:173
CellIndex_t NRows
Definition: dimensions.h:182
CellIndex_t NColumns
Definition: dimensions.h:197
CellIndex_t NConnections
Definition: dimensions.h:207
Structure used to store data about the heat dissipation through the top or bottom surfaces of the 2D/...
Definition: heat_sink.h:69
CellIndex_t NColumns
Definition: heat_sink.h:114
CellIndex_t NumColumnsBorder
Definition: heat_sink.h:126
HeatSinkModel_t SinkModel
Definition: heat_sink.h:72
CellIndex_t NumRowsBorder
Definition: heat_sink.h:120
CellIndex_t NRows
Definition: heat_sink.h:110
ChannelModel_t
Definition: types.h:346
@ TDICE_CHANNEL_MODEL_PF_INLINE
Inline pin fins - 2 Resistors model.
Definition: types.h:350
@ TDICE_CHANNEL_MODEL_PF_STAGGERED
Staggered pin fins - 2 Resistors model.
Definition: types.h:351
@ TDICE_CHANNEL_MODEL_NONE
Undefined type.
Definition: types.h:347
@ TDICE_CHANNEL_MODEL_MC_4RM
Microchannel - 4 Resistors model.
Definition: types.h:348
@ TDICE_CHANNEL_MODEL_MC_2RM
Microchannel - 2 Resistors model.
Definition: types.h:349
double ChipDimension_t
Definition: types.h:187
double CellDimension_t
Definition: types.h:177
uint32_t Quantity_t
Definition: types.h:59
uint32_t CellIndex_t
Definition: types.h:213
@ TDICE_HEATSINK_TOP_PLUGGABLE
Top pluggable heat sink.
Definition: types.h:228
#define NUM_LAYERS_CHANNEL_2RM
Definition: types.h:374