Open64 (mfef90, whirl2f, and IR tools)
TAG: version-openad; SVN changeset: 916
|
00001 /* 00002 00003 Copyright (C) 2000, 2001 Silicon Graphics, Inc. All Rights Reserved. 00004 00005 This program is free software; you can redistribute it and/or modify it 00006 under the terms of version 2.1 of the GNU Lesser General Public License 00007 as published by the Free Software Foundation. 00008 00009 This program is distributed in the hope that it would be useful, but 00010 WITHOUT ANY WARRANTY; without even the implied warranty of 00011 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 00012 00013 Further, this software is distributed without any warranty that it is 00014 free of the rightful claim of any third person regarding infringement 00015 or the like. Any license provided herein, whether implied or 00016 otherwise, applies only to this software file. Patent licenses, if 00017 any, provided herein do not apply to combinations of this program with 00018 other software, or any other product whatsoever. 00019 00020 You should have received a copy of the GNU Lesser General Public 00021 License along with this program; if not, write the Free Software 00022 Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, 00023 USA. 00024 00025 Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pky, 00026 Mountain View, CA 94043, or: 00027 00028 http://www.sgi.com 00029 00030 For further information regarding this notice, see: 00031 00032 http://oss.sgi.com/projects/GenInfo/NoticeExplan 00033 00034 */ 00035 00036 /* automatically generated file, do not edit */ 00037 00038 #include "f90_intrinsic.h" 00039 00040 static size_t read_source_desc(DopeVectorType * array, 00041 size_t src_extent[MAX_NARY_DIMS], 00042 size_t src_stride[MAX_NARY_DIMS], 00043 size_t src_offset[MAX_NARY_DIMS], 00044 int32_t ddim) ; 00045 00046 static void 00047 get_offset_and_stride(DopeVectorType * array, 00048 size_t src_extent[MAX_NARY_DIMS], 00049 size_t src_stride[MAX_NARY_DIMS], 00050 size_t src_offset[MAX_NARY_DIMS], 00051 int32_t ddim) ; 00052 00053 static uint32_t 00054 find_contig_axes(size_t src_extent[MAX_NARY_DIMS], 00055 size_t src_stride[MAX_NARY_DIMS], 00056 size_t src_offset[MAX_NARY_DIMS], 00057 uint32_t src_rank, 00058 size_t typ_sz, 00059 size_t msk_stride[MAX_NARY_DIMS], 00060 size_t msk_offset[MAX_NARY_DIMS], 00061 size_t msk_typ_sz) ; 00062 00063 static int32_t read_dim(DopeVectorType * dim) ; 00064 00065 i1 00066 _MAXVAL0__I1( 00067 DopeVectorType *array, 00068 DopeVectorType *dim, 00069 DopeVectorType *mask) 00070 { 00071 char * array_p, * array_b ; 00072 char * dim_p, * dim_b ; 00073 char * mask_p, * mask_b ; 00074 00075 size_t src_extent [MAX_NARY_DIMS] ; 00076 size_t counter [MAX_NARY_DIMS] ; 00077 size_t src_offset [MAX_NARY_DIMS] ; 00078 size_t src_stride [MAX_NARY_DIMS] ; 00079 size_t src_size ; 00080 00081 size_t msk_stride [MAX_NARY_DIMS] ; 00082 size_t msk_offset [MAX_NARY_DIMS] ; 00083 00084 int32_t ddim ; 00085 uint32_t src_rank ; 00086 uint32_t res_rank ; 00087 uint32_t jrank ; 00088 00089 size_t j,k,i ; 00090 size_t typ_sz; 00091 size_t msk_typ_sz; 00092 00093 i1 accum ; 00094 i1 const initv = INT8_MIN ; 00095 size_t a_size,a_stride; 00096 size_t m_stride ; 00097 00098 i1 temp,new ; 00099 00100 if (mask == NULL) { /* is third arg mask or dim? */ 00101 if (dim != NULL) { 00102 if (GET_DV_LOGICAL_FROM_DESC(dim)) { 00103 mask = (DopeVectorType *) dim ; 00104 dim = NULL; 00105 } 00106 } 00107 } 00108 00109 if (dim != NULL) { 00110 ddim = read_dim(dim); 00111 } else 00112 ddim = 0 ; 00113 00114 array_b = (char *) GET_ADDRESS_FROM_DESC(array) ; 00115 src_rank = GET_RANK_FROM_DESC(array) - 1; 00116 typ_sz = GET_ELEMENT_SZ_FROM_DESC(array); 00117 00118 src_size = read_source_desc(array, src_extent, src_stride, src_offset, ddim); 00119 00120 for (i = 0 ; i <= src_rank ; i ++) 00121 counter[i] = 0 ; 00122 00123 if (mask != NULL) { 00124 00125 msk_typ_sz = GET_ELEMENT_SZ_FROM_DESC(mask); 00126 mask_b = (char *) GET_ADDRESS_FROM_DESC(mask) + OFFSET_TO_TF_BYTE(msk_typ_sz) ; 00127 00128 if (GET_RANK_FROM_DESC(mask) == 0) { 00129 if (*mask_b) { 00130 mask = NULL; 00131 } else { 00132 src_size = 0; 00133 for (j = 0 ; j <= src_rank ; j ++) { 00134 msk_stride[j] = 0 ; 00135 msk_offset[j] = 0 ; 00136 } 00137 } 00138 00139 } else { 00140 00141 get_offset_and_stride(mask, src_extent, msk_stride, msk_offset, ddim); 00142 } 00143 } 00144 00145 accum = initv ; 00146 00147 if (src_size == 0 ) { 00148 return accum; 00149 } 00150 array_p = array_b ; 00151 if (mask == NULL) { 00152 00153 { 00154 size_t *p1 = NULL; 00155 size_t *p2 = NULL; 00156 size_t p3 = 0; 00157 00158 src_rank = find_contig_axes(src_extent, src_stride, src_offset, src_rank, typ_sz, p1,p2,p3) ; 00159 } 00160 00161 a_size = src_extent[0] ; 00162 a_stride = src_stride[0] ; 00163 00164 while (counter[src_rank] < src_extent[src_rank] ) { 00165 00166 for ( i = 0 ; i < a_size ; i ++ ) { 00167 if (*(i1 *)array_p > accum ) { 00168 accum = * (i1 *)array_p ; 00169 } 00170 array_p += a_stride ; 00171 } 00172 counter[0] = a_size ; 00173 j = 0 ; 00174 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00175 array_p += src_offset[j] ; 00176 counter[j+1]++ ; 00177 counter[j] = 0 ; 00178 j ++ ; 00179 } 00180 } 00181 } else { 00182 00183 { 00184 size_t *p1 = NULL; 00185 size_t *p2 = NULL; 00186 size_t p3 = 0; 00187 00188 p1 = msk_stride ; 00189 p2 = msk_offset ; 00190 p3 = msk_typ_sz ; 00191 00192 src_rank = find_contig_axes(src_extent, src_stride, src_offset, src_rank, typ_sz, p1,p2,p3) ; 00193 } 00194 00195 a_size = src_extent[0] ; 00196 a_stride = src_stride[0] ; 00197 m_stride = msk_stride[0] ; 00198 mask_p = mask_b ; 00199 00200 while (counter[src_rank] < src_extent[src_rank] ) { 00201 00202 for ( i = 0 ; i < a_size ; i ++ ) { 00203 if (*mask_p) { 00204 if (*(i1 *)array_p > accum ) { 00205 accum = * (i1 *)array_p ; 00206 } 00207 } 00208 array_p += a_stride ; 00209 mask_p += m_stride ; 00210 } 00211 counter[0] = a_size ; 00212 j = 0 ; 00213 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00214 array_p += src_offset[j] ; 00215 mask_p += msk_offset[j] ; 00216 counter[j+1]++ ; 00217 counter[j] = 0 ; 00218 j ++ ; 00219 } 00220 } 00221 } 00222 return accum ; 00223 } 00224 i2 00225 _MAXVAL0__I2( 00226 DopeVectorType *array, 00227 DopeVectorType *dim, 00228 DopeVectorType *mask) 00229 { 00230 char * array_p, * array_b ; 00231 char * dim_p, * dim_b ; 00232 char * mask_p, * mask_b ; 00233 00234 size_t src_extent [MAX_NARY_DIMS] ; 00235 size_t counter [MAX_NARY_DIMS] ; 00236 size_t src_offset [MAX_NARY_DIMS] ; 00237 size_t src_stride [MAX_NARY_DIMS] ; 00238 size_t src_size ; 00239 00240 size_t msk_stride [MAX_NARY_DIMS] ; 00241 size_t msk_offset [MAX_NARY_DIMS] ; 00242 00243 int32_t ddim ; 00244 uint32_t src_rank ; 00245 uint32_t res_rank ; 00246 uint32_t jrank ; 00247 00248 size_t j,k,i ; 00249 size_t typ_sz; 00250 size_t msk_typ_sz; 00251 00252 i2 accum ; 00253 i2 const initv = INT16_MIN ; 00254 size_t a_size,a_stride; 00255 size_t m_stride ; 00256 00257 i2 temp,new ; 00258 00259 if (mask == NULL) { /* is third arg mask or dim? */ 00260 if (dim != NULL) { 00261 if (GET_DV_LOGICAL_FROM_DESC(dim)) { 00262 mask = (DopeVectorType *) dim ; 00263 dim = NULL; 00264 } 00265 } 00266 } 00267 00268 if (dim != NULL) { 00269 ddim = read_dim(dim); 00270 } else 00271 ddim = 0 ; 00272 00273 array_b = (char *) GET_ADDRESS_FROM_DESC(array) ; 00274 src_rank = GET_RANK_FROM_DESC(array) - 1; 00275 typ_sz = GET_ELEMENT_SZ_FROM_DESC(array); 00276 00277 src_size = read_source_desc(array, src_extent, src_stride, src_offset, ddim); 00278 00279 for (i = 0 ; i <= src_rank ; i ++) 00280 counter[i] = 0 ; 00281 00282 if (mask != NULL) { 00283 00284 msk_typ_sz = GET_ELEMENT_SZ_FROM_DESC(mask); 00285 mask_b = (char *) GET_ADDRESS_FROM_DESC(mask) + OFFSET_TO_TF_BYTE(msk_typ_sz) ; 00286 00287 if (GET_RANK_FROM_DESC(mask) == 0) { 00288 if (*mask_b) { 00289 mask = NULL; 00290 } else { 00291 src_size = 0; 00292 for (j = 0 ; j <= src_rank ; j ++) { 00293 msk_stride[j] = 0 ; 00294 msk_offset[j] = 0 ; 00295 } 00296 } 00297 00298 } else { 00299 00300 get_offset_and_stride(mask, src_extent, msk_stride, msk_offset, ddim); 00301 } 00302 } 00303 00304 accum = initv ; 00305 00306 if (src_size == 0 ) { 00307 return accum; 00308 } 00309 array_p = array_b ; 00310 if (mask == NULL) { 00311 00312 { 00313 size_t *p1 = NULL; 00314 size_t *p2 = NULL; 00315 size_t p3 = 0; 00316 00317 src_rank = find_contig_axes(src_extent, src_stride, src_offset, src_rank, typ_sz, p1,p2,p3) ; 00318 } 00319 00320 a_size = src_extent[0] ; 00321 a_stride = src_stride[0] ; 00322 00323 while (counter[src_rank] < src_extent[src_rank] ) { 00324 00325 for ( i = 0 ; i < a_size ; i ++ ) { 00326 if (*(i2 *)array_p > accum ) { 00327 accum = * (i2 *)array_p ; 00328 } 00329 array_p += a_stride ; 00330 } 00331 counter[0] = a_size ; 00332 j = 0 ; 00333 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00334 array_p += src_offset[j] ; 00335 counter[j+1]++ ; 00336 counter[j] = 0 ; 00337 j ++ ; 00338 } 00339 } 00340 } else { 00341 00342 { 00343 size_t *p1 = NULL; 00344 size_t *p2 = NULL; 00345 size_t p3 = 0; 00346 00347 p1 = msk_stride ; 00348 p2 = msk_offset ; 00349 p3 = msk_typ_sz ; 00350 00351 src_rank = find_contig_axes(src_extent, src_stride, src_offset, src_rank, typ_sz, p1,p2,p3) ; 00352 } 00353 00354 a_size = src_extent[0] ; 00355 a_stride = src_stride[0] ; 00356 m_stride = msk_stride[0] ; 00357 mask_p = mask_b ; 00358 00359 while (counter[src_rank] < src_extent[src_rank] ) { 00360 00361 for ( i = 0 ; i < a_size ; i ++ ) { 00362 if (*mask_p) { 00363 if (*(i2 *)array_p > accum ) { 00364 accum = * (i2 *)array_p ; 00365 } 00366 } 00367 array_p += a_stride ; 00368 mask_p += m_stride ; 00369 } 00370 counter[0] = a_size ; 00371 j = 0 ; 00372 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00373 array_p += src_offset[j] ; 00374 mask_p += msk_offset[j] ; 00375 counter[j+1]++ ; 00376 counter[j] = 0 ; 00377 j ++ ; 00378 } 00379 } 00380 } 00381 return accum ; 00382 } 00383 i4 00384 _MAXVAL0__I4( 00385 DopeVectorType *array, 00386 DopeVectorType *dim, 00387 DopeVectorType *mask) 00388 { 00389 char * array_p, * array_b ; 00390 char * dim_p, * dim_b ; 00391 char * mask_p, * mask_b ; 00392 00393 size_t src_extent [MAX_NARY_DIMS] ; 00394 size_t counter [MAX_NARY_DIMS] ; 00395 size_t src_offset [MAX_NARY_DIMS] ; 00396 size_t src_stride [MAX_NARY_DIMS] ; 00397 size_t src_size ; 00398 00399 size_t msk_stride [MAX_NARY_DIMS] ; 00400 size_t msk_offset [MAX_NARY_DIMS] ; 00401 00402 int32_t ddim ; 00403 uint32_t src_rank ; 00404 uint32_t res_rank ; 00405 uint32_t jrank ; 00406 00407 size_t j,k,i ; 00408 size_t typ_sz; 00409 size_t msk_typ_sz; 00410 00411 i4 accum ; 00412 i4 const initv = INT32_MIN ; 00413 size_t a_size,a_stride; 00414 size_t m_stride ; 00415 00416 i4 temp,new ; 00417 00418 if (mask == NULL) { /* is third arg mask or dim? */ 00419 if (dim != NULL) { 00420 if (GET_DV_LOGICAL_FROM_DESC(dim)) { 00421 mask = (DopeVectorType *) dim ; 00422 dim = NULL; 00423 } 00424 } 00425 } 00426 00427 if (dim != NULL) { 00428 ddim = read_dim(dim); 00429 } else 00430 ddim = 0 ; 00431 00432 array_b = (char *) GET_ADDRESS_FROM_DESC(array) ; 00433 src_rank = GET_RANK_FROM_DESC(array) - 1; 00434 typ_sz = GET_ELEMENT_SZ_FROM_DESC(array); 00435 00436 src_size = read_source_desc(array, src_extent, src_stride, src_offset, ddim); 00437 00438 for (i = 0 ; i <= src_rank ; i ++) 00439 counter[i] = 0 ; 00440 00441 if (mask != NULL) { 00442 00443 msk_typ_sz = GET_ELEMENT_SZ_FROM_DESC(mask); 00444 mask_b = (char *) GET_ADDRESS_FROM_DESC(mask) + OFFSET_TO_TF_BYTE(msk_typ_sz) ; 00445 00446 if (GET_RANK_FROM_DESC(mask) == 0) { 00447 if (*mask_b) { 00448 mask = NULL; 00449 } else { 00450 src_size = 0; 00451 for (j = 0 ; j <= src_rank ; j ++) { 00452 msk_stride[j] = 0 ; 00453 msk_offset[j] = 0 ; 00454 } 00455 } 00456 00457 } else { 00458 00459 get_offset_and_stride(mask, src_extent, msk_stride, msk_offset, ddim); 00460 } 00461 } 00462 00463 accum = initv ; 00464 00465 if (src_size == 0 ) { 00466 return accum; 00467 } 00468 array_p = array_b ; 00469 if (mask == NULL) { 00470 00471 { 00472 size_t *p1 = NULL; 00473 size_t *p2 = NULL; 00474 size_t p3 = 0; 00475 00476 src_rank = find_contig_axes(src_extent, src_stride, src_offset, src_rank, typ_sz, p1,p2,p3) ; 00477 } 00478 00479 a_size = src_extent[0] ; 00480 a_stride = src_stride[0] ; 00481 00482 while (counter[src_rank] < src_extent[src_rank] ) { 00483 00484 for ( i = 0 ; i < a_size ; i ++ ) { 00485 if (*(i4 *)array_p > accum ) { 00486 accum = * (i4 *)array_p ; 00487 } 00488 array_p += a_stride ; 00489 } 00490 counter[0] = a_size ; 00491 j = 0 ; 00492 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00493 array_p += src_offset[j] ; 00494 counter[j+1]++ ; 00495 counter[j] = 0 ; 00496 j ++ ; 00497 } 00498 } 00499 } else { 00500 00501 { 00502 size_t *p1 = NULL; 00503 size_t *p2 = NULL; 00504 size_t p3 = 0; 00505 00506 p1 = msk_stride ; 00507 p2 = msk_offset ; 00508 p3 = msk_typ_sz ; 00509 00510 src_rank = find_contig_axes(src_extent, src_stride, src_offset, src_rank, typ_sz, p1,p2,p3) ; 00511 } 00512 00513 a_size = src_extent[0] ; 00514 a_stride = src_stride[0] ; 00515 m_stride = msk_stride[0] ; 00516 mask_p = mask_b ; 00517 00518 while (counter[src_rank] < src_extent[src_rank] ) { 00519 00520 for ( i = 0 ; i < a_size ; i ++ ) { 00521 if (*mask_p) { 00522 if (*(i4 *)array_p > accum ) { 00523 accum = * (i4 *)array_p ; 00524 } 00525 } 00526 array_p += a_stride ; 00527 mask_p += m_stride ; 00528 } 00529 counter[0] = a_size ; 00530 j = 0 ; 00531 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00532 array_p += src_offset[j] ; 00533 mask_p += msk_offset[j] ; 00534 counter[j+1]++ ; 00535 counter[j] = 0 ; 00536 j ++ ; 00537 } 00538 } 00539 } 00540 return accum ; 00541 } 00542 i8 00543 _MAXVAL0__J( 00544 DopeVectorType *array, 00545 DopeVectorType *dim, 00546 DopeVectorType *mask) 00547 { 00548 char * array_p, * array_b ; 00549 char * dim_p, * dim_b ; 00550 char * mask_p, * mask_b ; 00551 00552 size_t src_extent [MAX_NARY_DIMS] ; 00553 size_t counter [MAX_NARY_DIMS] ; 00554 size_t src_offset [MAX_NARY_DIMS] ; 00555 size_t src_stride [MAX_NARY_DIMS] ; 00556 size_t src_size ; 00557 00558 size_t msk_stride [MAX_NARY_DIMS] ; 00559 size_t msk_offset [MAX_NARY_DIMS] ; 00560 00561 int32_t ddim ; 00562 uint32_t src_rank ; 00563 uint32_t res_rank ; 00564 uint32_t jrank ; 00565 00566 size_t j,k,i ; 00567 size_t typ_sz; 00568 size_t msk_typ_sz; 00569 00570 i8 accum ; 00571 i8 const initv = INT64_MIN ; 00572 size_t a_size,a_stride; 00573 size_t m_stride ; 00574 00575 i8 temp,new ; 00576 00577 if (mask == NULL) { /* is third arg mask or dim? */ 00578 if (dim != NULL) { 00579 if (GET_DV_LOGICAL_FROM_DESC(dim)) { 00580 mask = (DopeVectorType *) dim ; 00581 dim = NULL; 00582 } 00583 } 00584 } 00585 00586 if (dim != NULL) { 00587 ddim = read_dim(dim); 00588 } else 00589 ddim = 0 ; 00590 00591 array_b = (char *) GET_ADDRESS_FROM_DESC(array) ; 00592 src_rank = GET_RANK_FROM_DESC(array) - 1; 00593 typ_sz = GET_ELEMENT_SZ_FROM_DESC(array); 00594 00595 src_size = read_source_desc(array, src_extent, src_stride, src_offset, ddim); 00596 00597 for (i = 0 ; i <= src_rank ; i ++) 00598 counter[i] = 0 ; 00599 00600 if (mask != NULL) { 00601 00602 msk_typ_sz = GET_ELEMENT_SZ_FROM_DESC(mask); 00603 mask_b = (char *) GET_ADDRESS_FROM_DESC(mask) + OFFSET_TO_TF_BYTE(msk_typ_sz) ; 00604 00605 if (GET_RANK_FROM_DESC(mask) == 0) { 00606 if (*mask_b) { 00607 mask = NULL; 00608 } else { 00609 src_size = 0; 00610 for (j = 0 ; j <= src_rank ; j ++) { 00611 msk_stride[j] = 0 ; 00612 msk_offset[j] = 0 ; 00613 } 00614 } 00615 00616 } else { 00617 00618 get_offset_and_stride(mask, src_extent, msk_stride, msk_offset, ddim); 00619 } 00620 } 00621 00622 accum = initv ; 00623 00624 if (src_size == 0 ) { 00625 return accum; 00626 } 00627 array_p = array_b ; 00628 if (mask == NULL) { 00629 00630 { 00631 size_t *p1 = NULL; 00632 size_t *p2 = NULL; 00633 size_t p3 = 0; 00634 00635 src_rank = find_contig_axes(src_extent, src_stride, src_offset, src_rank, typ_sz, p1,p2,p3) ; 00636 } 00637 00638 a_size = src_extent[0] ; 00639 a_stride = src_stride[0] ; 00640 00641 while (counter[src_rank] < src_extent[src_rank] ) { 00642 00643 for ( i = 0 ; i < a_size ; i ++ ) { 00644 if (*(i8 *)array_p > accum ) { 00645 accum = * (i8 *)array_p ; 00646 } 00647 array_p += a_stride ; 00648 } 00649 counter[0] = a_size ; 00650 j = 0 ; 00651 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00652 array_p += src_offset[j] ; 00653 counter[j+1]++ ; 00654 counter[j] = 0 ; 00655 j ++ ; 00656 } 00657 } 00658 } else { 00659 00660 { 00661 size_t *p1 = NULL; 00662 size_t *p2 = NULL; 00663 size_t p3 = 0; 00664 00665 p1 = msk_stride ; 00666 p2 = msk_offset ; 00667 p3 = msk_typ_sz ; 00668 00669 src_rank = find_contig_axes(src_extent, src_stride, src_offset, src_rank, typ_sz, p1,p2,p3) ; 00670 } 00671 00672 a_size = src_extent[0] ; 00673 a_stride = src_stride[0] ; 00674 m_stride = msk_stride[0] ; 00675 mask_p = mask_b ; 00676 00677 while (counter[src_rank] < src_extent[src_rank] ) { 00678 00679 for ( i = 0 ; i < a_size ; i ++ ) { 00680 if (*mask_p) { 00681 if (*(i8 *)array_p > accum ) { 00682 accum = * (i8 *)array_p ; 00683 } 00684 } 00685 array_p += a_stride ; 00686 mask_p += m_stride ; 00687 } 00688 counter[0] = a_size ; 00689 j = 0 ; 00690 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00691 array_p += src_offset[j] ; 00692 mask_p += msk_offset[j] ; 00693 counter[j+1]++ ; 00694 counter[j] = 0 ; 00695 j ++ ; 00696 } 00697 } 00698 } 00699 return accum ; 00700 } 00701 r4 00702 _MAXVAL0__S4( 00703 DopeVectorType *array, 00704 DopeVectorType *dim, 00705 DopeVectorType *mask) 00706 { 00707 char * array_p, * array_b ; 00708 char * dim_p, * dim_b ; 00709 char * mask_p, * mask_b ; 00710 00711 size_t src_extent [MAX_NARY_DIMS] ; 00712 size_t counter [MAX_NARY_DIMS] ; 00713 size_t src_offset [MAX_NARY_DIMS] ; 00714 size_t src_stride [MAX_NARY_DIMS] ; 00715 size_t src_size ; 00716 00717 size_t msk_stride [MAX_NARY_DIMS] ; 00718 size_t msk_offset [MAX_NARY_DIMS] ; 00719 00720 int32_t ddim ; 00721 uint32_t src_rank ; 00722 uint32_t res_rank ; 00723 uint32_t jrank ; 00724 00725 size_t j,k,i ; 00726 size_t typ_sz; 00727 size_t msk_typ_sz; 00728 00729 r4 accum ; 00730 r4 const initv = -HUGE_REAL4_F90 ; 00731 size_t a_size,a_stride; 00732 size_t m_stride ; 00733 00734 r4 temp,new ; 00735 00736 if (mask == NULL) { /* is third arg mask or dim? */ 00737 if (dim != NULL) { 00738 if (GET_DV_LOGICAL_FROM_DESC(dim)) { 00739 mask = (DopeVectorType *) dim ; 00740 dim = NULL; 00741 } 00742 } 00743 } 00744 00745 if (dim != NULL) { 00746 ddim = read_dim(dim); 00747 } else 00748 ddim = 0 ; 00749 00750 array_b = (char *) GET_ADDRESS_FROM_DESC(array) ; 00751 src_rank = GET_RANK_FROM_DESC(array) - 1; 00752 typ_sz = GET_ELEMENT_SZ_FROM_DESC(array); 00753 00754 src_size = read_source_desc(array, src_extent, src_stride, src_offset, ddim); 00755 00756 for (i = 0 ; i <= src_rank ; i ++) 00757 counter[i] = 0 ; 00758 00759 if (mask != NULL) { 00760 00761 msk_typ_sz = GET_ELEMENT_SZ_FROM_DESC(mask); 00762 mask_b = (char *) GET_ADDRESS_FROM_DESC(mask) + OFFSET_TO_TF_BYTE(msk_typ_sz) ; 00763 00764 if (GET_RANK_FROM_DESC(mask) == 0) { 00765 if (*mask_b) { 00766 mask = NULL; 00767 } else { 00768 src_size = 0; 00769 for (j = 0 ; j <= src_rank ; j ++) { 00770 msk_stride[j] = 0 ; 00771 msk_offset[j] = 0 ; 00772 } 00773 } 00774 00775 } else { 00776 00777 get_offset_and_stride(mask, src_extent, msk_stride, msk_offset, ddim); 00778 } 00779 } 00780 00781 accum = initv ; 00782 00783 if (src_size == 0 ) { 00784 return accum; 00785 } 00786 array_p = array_b ; 00787 if (mask == NULL) { 00788 00789 { 00790 size_t *p1 = NULL; 00791 size_t *p2 = NULL; 00792 size_t p3 = 0; 00793 00794 src_rank = find_contig_axes(src_extent, src_stride, src_offset, src_rank, typ_sz, p1,p2,p3) ; 00795 } 00796 00797 a_size = src_extent[0] ; 00798 a_stride = src_stride[0] ; 00799 00800 while (counter[src_rank] < src_extent[src_rank] ) { 00801 00802 for ( i = 0 ; i < a_size ; i ++ ) { 00803 if (*(r4 *)array_p > accum ) { 00804 accum = * (r4 *)array_p ; 00805 } 00806 array_p += a_stride ; 00807 } 00808 counter[0] = a_size ; 00809 j = 0 ; 00810 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00811 array_p += src_offset[j] ; 00812 counter[j+1]++ ; 00813 counter[j] = 0 ; 00814 j ++ ; 00815 } 00816 } 00817 } else { 00818 00819 { 00820 size_t *p1 = NULL; 00821 size_t *p2 = NULL; 00822 size_t p3 = 0; 00823 00824 p1 = msk_stride ; 00825 p2 = msk_offset ; 00826 p3 = msk_typ_sz ; 00827 00828 src_rank = find_contig_axes(src_extent, src_stride, src_offset, src_rank, typ_sz, p1,p2,p3) ; 00829 } 00830 00831 a_size = src_extent[0] ; 00832 a_stride = src_stride[0] ; 00833 m_stride = msk_stride[0] ; 00834 mask_p = mask_b ; 00835 00836 while (counter[src_rank] < src_extent[src_rank] ) { 00837 00838 for ( i = 0 ; i < a_size ; i ++ ) { 00839 if (*mask_p) { 00840 if (*(r4 *)array_p > accum ) { 00841 accum = * (r4 *)array_p ; 00842 } 00843 } 00844 array_p += a_stride ; 00845 mask_p += m_stride ; 00846 } 00847 counter[0] = a_size ; 00848 j = 0 ; 00849 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00850 array_p += src_offset[j] ; 00851 mask_p += msk_offset[j] ; 00852 counter[j+1]++ ; 00853 counter[j] = 0 ; 00854 j ++ ; 00855 } 00856 } 00857 } 00858 return accum ; 00859 } 00860 r8 00861 _MAXVAL0__S( 00862 DopeVectorType *array, 00863 DopeVectorType *dim, 00864 DopeVectorType *mask) 00865 { 00866 char * array_p, * array_b ; 00867 char * dim_p, * dim_b ; 00868 char * mask_p, * mask_b ; 00869 00870 size_t src_extent [MAX_NARY_DIMS] ; 00871 size_t counter [MAX_NARY_DIMS] ; 00872 size_t src_offset [MAX_NARY_DIMS] ; 00873 size_t src_stride [MAX_NARY_DIMS] ; 00874 size_t src_size ; 00875 00876 size_t msk_stride [MAX_NARY_DIMS] ; 00877 size_t msk_offset [MAX_NARY_DIMS] ; 00878 00879 int32_t ddim ; 00880 uint32_t src_rank ; 00881 uint32_t res_rank ; 00882 uint32_t jrank ; 00883 00884 size_t j,k,i ; 00885 size_t typ_sz; 00886 size_t msk_typ_sz; 00887 00888 r8 accum ; 00889 r8 const initv = -HUGE_REAL8_F90 ; 00890 size_t a_size,a_stride; 00891 size_t m_stride ; 00892 00893 r8 temp,new ; 00894 00895 if (mask == NULL) { /* is third arg mask or dim? */ 00896 if (dim != NULL) { 00897 if (GET_DV_LOGICAL_FROM_DESC(dim)) { 00898 mask = (DopeVectorType *) dim ; 00899 dim = NULL; 00900 } 00901 } 00902 } 00903 00904 if (dim != NULL) { 00905 ddim = read_dim(dim); 00906 } else 00907 ddim = 0 ; 00908 00909 array_b = (char *) GET_ADDRESS_FROM_DESC(array) ; 00910 src_rank = GET_RANK_FROM_DESC(array) - 1; 00911 typ_sz = GET_ELEMENT_SZ_FROM_DESC(array); 00912 00913 src_size = read_source_desc(array, src_extent, src_stride, src_offset, ddim); 00914 00915 for (i = 0 ; i <= src_rank ; i ++) 00916 counter[i] = 0 ; 00917 00918 if (mask != NULL) { 00919 00920 msk_typ_sz = GET_ELEMENT_SZ_FROM_DESC(mask); 00921 mask_b = (char *) GET_ADDRESS_FROM_DESC(mask) + OFFSET_TO_TF_BYTE(msk_typ_sz) ; 00922 00923 if (GET_RANK_FROM_DESC(mask) == 0) { 00924 if (*mask_b) { 00925 mask = NULL; 00926 } else { 00927 src_size = 0; 00928 for (j = 0 ; j <= src_rank ; j ++) { 00929 msk_stride[j] = 0 ; 00930 msk_offset[j] = 0 ; 00931 } 00932 } 00933 00934 } else { 00935 00936 get_offset_and_stride(mask, src_extent, msk_stride, msk_offset, ddim); 00937 } 00938 } 00939 00940 accum = initv ; 00941 00942 if (src_size == 0 ) { 00943 return accum; 00944 } 00945 array_p = array_b ; 00946 if (mask == NULL) { 00947 00948 { 00949 size_t *p1 = NULL; 00950 size_t *p2 = NULL; 00951 size_t p3 = 0; 00952 00953 src_rank = find_contig_axes(src_extent, src_stride, src_offset, src_rank, typ_sz, p1,p2,p3) ; 00954 } 00955 00956 a_size = src_extent[0] ; 00957 a_stride = src_stride[0] ; 00958 00959 while (counter[src_rank] < src_extent[src_rank] ) { 00960 00961 for ( i = 0 ; i < a_size ; i ++ ) { 00962 if (*(r8 *)array_p > accum ) { 00963 accum = * (r8 *)array_p ; 00964 } 00965 array_p += a_stride ; 00966 } 00967 counter[0] = a_size ; 00968 j = 0 ; 00969 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00970 array_p += src_offset[j] ; 00971 counter[j+1]++ ; 00972 counter[j] = 0 ; 00973 j ++ ; 00974 } 00975 } 00976 } else { 00977 00978 { 00979 size_t *p1 = NULL; 00980 size_t *p2 = NULL; 00981 size_t p3 = 0; 00982 00983 p1 = msk_stride ; 00984 p2 = msk_offset ; 00985 p3 = msk_typ_sz ; 00986 00987 src_rank = find_contig_axes(src_extent, src_stride, src_offset, src_rank, typ_sz, p1,p2,p3) ; 00988 } 00989 00990 a_size = src_extent[0] ; 00991 a_stride = src_stride[0] ; 00992 m_stride = msk_stride[0] ; 00993 mask_p = mask_b ; 00994 00995 while (counter[src_rank] < src_extent[src_rank] ) { 00996 00997 for ( i = 0 ; i < a_size ; i ++ ) { 00998 if (*mask_p) { 00999 if (*(r8 *)array_p > accum ) { 01000 accum = * (r8 *)array_p ; 01001 } 01002 } 01003 array_p += a_stride ; 01004 mask_p += m_stride ; 01005 } 01006 counter[0] = a_size ; 01007 j = 0 ; 01008 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 01009 array_p += src_offset[j] ; 01010 mask_p += msk_offset[j] ; 01011 counter[j+1]++ ; 01012 counter[j] = 0 ; 01013 j ++ ; 01014 } 01015 } 01016 } 01017 return accum ; 01018 } 01019 r16 01020 _MAXVAL0__D( 01021 DopeVectorType *array, 01022 DopeVectorType *dim, 01023 DopeVectorType *mask) 01024 { 01025 char * array_p, * array_b ; 01026 char * dim_p, * dim_b ; 01027 char * mask_p, * mask_b ; 01028 01029 size_t src_extent [MAX_NARY_DIMS] ; 01030 size_t counter [MAX_NARY_DIMS] ; 01031 size_t src_offset [MAX_NARY_DIMS] ; 01032 size_t src_stride [MAX_NARY_DIMS] ; 01033 size_t src_size ; 01034 01035 size_t msk_stride [MAX_NARY_DIMS] ; 01036 size_t msk_offset [MAX_NARY_DIMS] ; 01037 01038 int32_t ddim ; 01039 uint32_t src_rank ; 01040 uint32_t res_rank ; 01041 uint32_t jrank ; 01042 01043 size_t j,k,i ; 01044 size_t typ_sz; 01045 size_t msk_typ_sz; 01046 01047 r16 accum ; 01048 r16 const initv = -HUGE_REAL16_F90 ; 01049 size_t a_size,a_stride; 01050 size_t m_stride ; 01051 01052 r16 temp,new ; 01053 01054 if (mask == NULL) { /* is third arg mask or dim? */ 01055 if (dim != NULL) { 01056 if (GET_DV_LOGICAL_FROM_DESC(dim)) { 01057 mask = (DopeVectorType *) dim ; 01058 dim = NULL; 01059 } 01060 } 01061 } 01062 01063 if (dim != NULL) { 01064 ddim = read_dim(dim); 01065 } else 01066 ddim = 0 ; 01067 01068 array_b = (char *) GET_ADDRESS_FROM_DESC(array) ; 01069 src_rank = GET_RANK_FROM_DESC(array) - 1; 01070 typ_sz = GET_ELEMENT_SZ_FROM_DESC(array); 01071 01072 src_size = read_source_desc(array, src_extent, src_stride, src_offset, ddim); 01073 01074 for (i = 0 ; i <= src_rank ; i ++) 01075 counter[i] = 0 ; 01076 01077 if (mask != NULL) { 01078 01079 msk_typ_sz = GET_ELEMENT_SZ_FROM_DESC(mask); 01080 mask_b = (char *) GET_ADDRESS_FROM_DESC(mask) + OFFSET_TO_TF_BYTE(msk_typ_sz) ; 01081 01082 if (GET_RANK_FROM_DESC(mask) == 0) { 01083 if (*mask_b) { 01084 mask = NULL; 01085 } else { 01086 src_size = 0; 01087 for (j = 0 ; j <= src_rank ; j ++) { 01088 msk_stride[j] = 0 ; 01089 msk_offset[j] = 0 ; 01090 } 01091 } 01092 01093 } else { 01094 01095 get_offset_and_stride(mask, src_extent, msk_stride, msk_offset, ddim); 01096 } 01097 } 01098 01099 accum = initv ; 01100 01101 if (src_size == 0 ) { 01102 return accum; 01103 } 01104 array_p = array_b ; 01105 if (mask == NULL) { 01106 01107 { 01108 size_t *p1 = NULL; 01109 size_t *p2 = NULL; 01110 size_t p3 = 0; 01111 01112 src_rank = find_contig_axes(src_extent, src_stride, src_offset, src_rank, typ_sz, p1,p2,p3) ; 01113 } 01114 01115 a_size = src_extent[0] ; 01116 a_stride = src_stride[0] ; 01117 01118 while (counter[src_rank] < src_extent[src_rank] ) { 01119 01120 for ( i = 0 ; i < a_size ; i ++ ) { 01121 if (*(r16 *)array_p > accum ) { 01122 accum = * (r16 *)array_p ; 01123 } 01124 array_p += a_stride ; 01125 } 01126 counter[0] = a_size ; 01127 j = 0 ; 01128 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 01129 array_p += src_offset[j] ; 01130 counter[j+1]++ ; 01131 counter[j] = 0 ; 01132 j ++ ; 01133 } 01134 } 01135 } else { 01136 01137 { 01138 size_t *p1 = NULL; 01139 size_t *p2 = NULL; 01140 size_t p3 = 0; 01141 01142 p1 = msk_stride ; 01143 p2 = msk_offset ; 01144 p3 = msk_typ_sz ; 01145 01146 src_rank = find_contig_axes(src_extent, src_stride, src_offset, src_rank, typ_sz, p1,p2,p3) ; 01147 } 01148 01149 a_size = src_extent[0] ; 01150 a_stride = src_stride[0] ; 01151 m_stride = msk_stride[0] ; 01152 mask_p = mask_b ; 01153 01154 while (counter[src_rank] < src_extent[src_rank] ) { 01155 01156 for ( i = 0 ; i < a_size ; i ++ ) { 01157 if (*mask_p) { 01158 if (*(r16 *)array_p > accum ) { 01159 accum = * (r16 *)array_p ; 01160 } 01161 } 01162 array_p += a_stride ; 01163 mask_p += m_stride ; 01164 } 01165 counter[0] = a_size ; 01166 j = 0 ; 01167 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 01168 array_p += src_offset[j] ; 01169 mask_p += msk_offset[j] ; 01170 counter[j+1]++ ; 01171 counter[j] = 0 ; 01172 j ++ ; 01173 } 01174 } 01175 } 01176 return accum ; 01177 } 01178 01179 static int32_t 01180 read_dim(DopeVectorType * dim) 01181 { 01182 int32_t ddim ; 01183 char * dim_p ; 01184 01185 dim_p = (char *) GET_ADDRESS_FROM_DESC(dim) ; 01186 01187 switch (GET_ELEMENT_SZ_FROM_DESC(dim)) { 01188 case sizeof(int8_t): 01189 ddim = * (int8_t *) dim_p ; 01190 break; 01191 01192 case sizeof(int16_t): 01193 ddim = * (int16_t *) dim_p ; 01194 break; 01195 01196 case sizeof(int32_t): 01197 ddim = * (int32_t *) dim_p ; 01198 break; 01199 01200 case sizeof(int64_t): 01201 ddim = * (int64_t *) dim_p ; 01202 break; 01203 } 01204 01205 return (ddim - 1) ; 01206 } 01207 01208 static size_t 01209 read_source_desc(DopeVectorType * array, 01210 size_t src_extent[MAX_NARY_DIMS], 01211 size_t src_stride[MAX_NARY_DIMS], 01212 size_t src_offset[MAX_NARY_DIMS], 01213 int32_t ddim) 01214 { 01215 int32_t src_rank ,k,j ; 01216 size_t src_size ; 01217 01218 src_extent[0] = GET_EXTENT_FROM_DESC(array,ddim) ; 01219 src_rank = GET_RANK_FROM_DESC(array); 01220 01221 src_size = src_extent[0]; 01222 01223 for ( k = 1, j = 0 ; j < src_rank ; j ++ ) { 01224 if (j != ddim ) { 01225 src_extent[k] = GET_EXTENT_FROM_DESC(array,j) ; 01226 src_size *= src_extent[k]; 01227 k++ ; 01228 } 01229 } 01230 get_offset_and_stride(array, src_extent, src_stride, src_offset, ddim); 01231 01232 return src_size; 01233 } 01234 01235 static void 01236 get_offset_and_stride(DopeVectorType * array, 01237 size_t src_extent[MAX_NARY_DIMS], 01238 size_t src_stride[MAX_NARY_DIMS], 01239 size_t src_offset[MAX_NARY_DIMS], 01240 int32_t ddim) 01241 { 01242 01243 int32_t src_rank ,k,j ; 01244 01245 src_stride[0] = GET_STRIDE_FROM_DESC(array,ddim) ; 01246 src_offset[0] = 0; 01247 src_rank = GET_RANK_FROM_DESC(array); 01248 01249 for ( k = 1, j = 0 ; j < src_rank ; j ++ ) { 01250 if (j != ddim ) { 01251 src_stride[k] = GET_STRIDE_FROM_DESC(array,j) ; 01252 src_offset[k-1] = src_stride[k] - (src_stride [k-1] * (src_extent[k-1])) ; 01253 k++ ; 01254 } 01255 } 01256 } 01257 01258 static uint32_t 01259 find_contig_axes(size_t src_extent[MAX_NARY_DIMS], 01260 size_t src_stride[MAX_NARY_DIMS], 01261 size_t src_offset[MAX_NARY_DIMS], 01262 uint32_t src_rank, 01263 size_t typ_sz, 01264 size_t msk_stride[MAX_NARY_DIMS], 01265 size_t msk_offset[MAX_NARY_DIMS], 01266 size_t msk_typ_sz) 01267 { 01268 uint32_t i,j ; 01269 size_t jrank; 01270 size_t * p ; 01271 01272 p = msk_stride ; 01273 01274 jrank = src_rank ; 01275 j = 1 ; 01276 while ((j <= jrank) &&((src_extent[0] * typ_sz) == src_stride[j]) &&(((p == NULL) ||((src_extent[0] * msk_typ_sz) == 01277 msk_stride[j]))) ) { 01278 src_extent[0] *= src_extent[j] ; 01279 src_offset[0] = src_offset[j] ; 01280 if (p != NULL) 01281 msk_offset[0] = msk_offset[j] ; 01282 src_rank -- ; 01283 j++ ; 01284 } 01285 for (i = j ; ( i <= jrank && i > 1) ; i ++ ) { 01286 src_stride[i-j+1] = src_stride[i] ; 01287 src_offset[i-j+1] = src_offset[i] ; 01288 src_extent[i-j+1] = src_extent[i] ; 01289 if (p != NULL) { 01290 msk_stride[i-j+1] = msk_stride[i] ; 01291 msk_offset[i-j+1] = msk_offset[i] ; 01292 } 01293 } 01294 return src_rank ; 01295 }