// // Copyright (c) 2017 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // #include "harness/compat.h" #include "harness/rounding_mode.h" #include "harness/kernelHelpers.h" #include "test_printf.h" #include // Helpers for generating runtime reference results static void intRefBuilder(printDataGenParameters&, char*, const size_t); static void floatRefBuilder(printDataGenParameters&, char* rResult, const size_t); static void octalRefBuilder(printDataGenParameters&, char*, const size_t); static void unsignedRefBuilder(printDataGenParameters&, char*, const size_t); static void hexRefBuilder(printDataGenParameters&, char*, const size_t); //================================== // int //================================== //------------------------------------------------------ // [string] format | [string] int-data representation | //------------------------------------------------------ std::vector printIntGenParameters = { //(Minimum)Five-wide,default(right)-justified {"%5d","10"}, //(Minimum)Five-wide,left-justified {"%-5d","10"}, //(Minimum)Five-wide,default(right)-justified,zero-filled {"%05d","10"}, //(Minimum)Five-wide,default(right)-justified,with sign {"%+5d","10"}, //(Minimum)Five-wide ,left-justified,with sign {"%-+5d","10"}, //(Minimum)Five-digit(zero-filled in absent digits),default(right)-justified {"%.5i","100"}, //(Minimum)Six-wide,Five-digit(zero-filled in absent digits),default(right)-justified {"%6.5i","100"}, //0 and - flag both apper ==>0 is ignored,left-justified,capital I {"%-06i","100"}, //(Minimum)Six-wide,Five-digit(zero-filled in absent digits),default(right)-justified {"%06.5i","100"} }; //----------------------------------------------- //test case for int | //----------------------------------------------- testCase testCaseInt = { TYPE_INT, correctBufferInt, printIntGenParameters, intRefBuilder, kint }; //============================================== // float //============================================== //-------------------------------------------------------- // [string] format | [string] float-data representation | //-------------------------------------------------------- std::vector printFloatGenParameters = { //Default(right)-justified {"%f","10.3456"}, //One position after the decimal,default(right)-justified {"%.1f","10.3456"}, //Two positions after the decimal,default(right)-justified {"%.2f","10.3456"}, //(Minimum)Eight-wide,three positions after the decimal,default(right)-justified {"%8.3f","10.3456"}, //(Minimum)Eight-wide,two positions after the decimal,zero-filled,default(right)-justified {"%08.2f","10.3456"}, //(Minimum)Eight-wide,two positions after the decimal,left-justified {"%-8.2f","10.3456"}, //(Minimum)Eight-wide,two positions after the decimal,with sign,default(right)-justified {"%+8.2f","-10.3456"}, //Zero positions after the decimal([floor]rounding),default(right)-justified {"%.0f","0.1"}, //Zero positions after the decimal([ceil]rounding),default(right)-justified {"%.0f","0.6"}, //Zero-filled,default positions number after the decimal,default(right)-justified {"%0f","0.6"}, //Double argument representing floating-point,used by f style,default(right)-justified {"%4g","12345.6789"}, //Double argument representing floating-point,used by e style,default(right)-justified {"%4.2g","12345.6789"}, //Double argument representing floating-point,used by f style,default(right)-justified {"%4G","0.0000023"}, //Double argument representing floating-point,used by e style,default(right)-justified {"%4G","0.023"}, //Double argument representing floating-point,with exponent,left-justified,default(right)-justified {"%-#20.15e","789456123.0"}, //Double argument representing floating-point,with exponent,left-justified,with sign,capital E,default(right)-justified {"%+#21.15E","789456123.0"}, //Double argument representing floating-point,in [-]xh.hhhhpAd style {"%.6a","0.1"}, //(Minimum)Ten-wide,Double argument representing floating-point,in xh.hhhhpAd style,default(right)-justified {"%10.2a","9990.235"}, }; //--------------------------------------------------------- //Test case for float | //--------------------------------------------------------- testCase testCaseFloat = { TYPE_FLOAT, correctBufferFloat, printFloatGenParameters, floatRefBuilder, kfloat }; //============================================== // float limits //============================================== //-------------------------------------------------------- // [string] format | [string] float-data representation | //-------------------------------------------------------- std::vector printFloatLimitsGenParameters = { //Infinity (1.0/0.0) {"%f","1.0f/0.0f"}, //NaN {"%f","sqrt(-1.0f)"}, //NaN {"%f","acospi(2.0f)"} }; //-------------------------------------------------------- // Lookup table - [string]float-correct buffer | //-------------------------------------------------------- std::vector correctBufferFloatLimits = { "inf", "-nan", "nan" }; //--------------------------------------------------------- //Test case for float | //--------------------------------------------------------- testCase testCaseFloatLimits = { TYPE_FLOAT_LIMITS, correctBufferFloatLimits, printFloatLimitsGenParameters, NULL }; //========================================================= // octal //========================================================= //--------------------------------------------------------- // [string] format | [string] octal-data representation | //--------------------------------------------------------- std::vector printOctalGenParameters = { //Default(right)-justified {"%o","10"}, //Five-digit,default(right)-justified {"%.5o","10"}, //Default(right)-justified,increase precision {"%#o","100000000"}, //(Minimum)Four-wide,Five-digit,0-flag ignored(because of precision),default(right)-justified {"%04.5o","10"} }; //------------------------------------------------------- //Test case for octal | //------------------------------------------------------- testCase testCaseOctal = { TYPE_OCTAL, correctBufferOctal, printOctalGenParameters, octalRefBuilder, kulong }; //========================================================= // unsigned //========================================================= //--------------------------------------------------------- // [string] format | [string] unsined-data representation | //--------------------------------------------------------- std::vector printUnsignedGenParameters = { //Default(right)-justified {"%u","10"}, //Zero precision for zero,default(right)-justified {"%.0u","0"}, }; //------------------------------------------------------- //Test case for octal | //------------------------------------------------------- testCase testCaseUnsigned = { TYPE_UNSIGNED, correctBufferUnsigned, printUnsignedGenParameters, unsignedRefBuilder, kulong }; //======================================================= // hexadecimal //======================================================= //-------------------------------------------------------------- // [string] format | [string] hexadecimal-data representation | //-------------------------------------------------------------- std::vector printHexadecimalGenParameters = { //Add 0x,low x,default(right)-justified {"%#x","0xABCDEF"}, //Add 0x,capital X,default(right)-justified {"%#X","0xABCDEF"}, //Not add 0x,if zero,default(right)-justified {"%#X","0"}, //(Minimum)Eight-wide,default(right)-justified {"%8x","399"}, //(Minimum)Four-wide,zero-filled,default(right)-justified {"%04x","399"} }; //-------------------------------------------------------------- //Test case for hexadecimal | //-------------------------------------------------------------- testCase testCaseHexadecimal = { TYPE_HEXADEC, correctBufferHexadecimal, printHexadecimalGenParameters, hexRefBuilder, kulong }; //============================================================= // char //============================================================= //----------------------------------------------------------- // [string] format | [string] string-data representation | //----------------------------------------------------------- std::vector printCharGenParameters = { //Four-wide,zero-filled,default(right)-justified {"%4c","\'1\'"}, //Four-wide,left-justified {"%-4c","\'1\'"}, //(unsigned) int argument,default(right)-justified {"%c","66"} }; //--------------------------------------------------------- // Lookup table -[string] char-correct buffer | //--------------------------------------------------------- std::vector correctBufferChar = { " 1", "1 ", "B", }; //---------------------------------------------------------- //Test case for char | //---------------------------------------------------------- testCase testCaseChar = { TYPE_CHAR, correctBufferChar, printCharGenParameters, NULL, kchar }; //========================================================== // string //========================================================== //-------------------------------------------------------- // [string]format | [string] string-data representation | //-------------------------------------------------------- std::vector printStringGenParameters = { //(Minimum)Four-wide,zero-filled,default(right)-justified {"%4s","\"foo\""}, //One-digit(precision ignored),left-justified {"%.1s","\"foo\""}, //%% specification {"%s","\"%%\""}, }; //--------------------------------------------------------- // Lookup table -[string] string-correct buffer | //--------------------------------------------------------- std::vector correctBufferString = { " foo", "f", "%%", }; //--------------------------------------------------------- //Test case for string | //--------------------------------------------------------- testCase testCaseString = { TYPE_STRING, correctBufferString, printStringGenParameters, NULL, kchar }; //========================================================= // vector //========================================================= //------------------------------------------------------------------------------------------------------------------- //[string] flag | [string] specifier | [string] type | [string] vector-data representation | [string] vector size | //------------------------------------------------------------------------------------------------------------------- std::vector printVectorGenParameters = { //(Minimum)Two-wide,two positions after decimal {NULL,"(1.0f,2.0f,3.0f,4.0f)","%2.2","hlf","float","4"}, //Alternative form,uchar argument {NULL,"(0xFA,0xFB)","%#","hhx","uchar","2"}, //Alternative form,ushort argument {NULL,"(0x1234,0x8765)","%#","hx","ushort","2"}, //Alternative form,uint argument {NULL,"(0x12345678,0x87654321)","%#","hlx","uint","2"}, //Alternative form,long argument {NULL,"(12345678,98765432)","%","ld","long","2"} }; //------------------------------------------------------------ // Lookup table -[string] vector-correct buffer | //------------------------------------------------------------ std::vector correctBufferVector = { "1.00,2.00,3.00,4.00", "0xfa,0xfb", "0x1234,0x8765", "0x12345678,0x87654321", "12345678,98765432" }; //----------------------------------------------------------- //Test case for vector | //----------------------------------------------------------- testCase testCaseVector = { TYPE_VECTOR, correctBufferVector, printVectorGenParameters, NULL }; //================================================================== // address space //================================================================== //------------------------------------------------------------------------------------------------------------------------------------------------------------------- // [string] argument type qualifier |[string] variable type qualifier + initialization | [string] format | [string] parameter |[string]%p indicator/additional code | //------------------------------------------------------------------------------------------------------------------------------------------------------------------- std::vector printAddrSpaceGenParameters = { //Global memory region {"\"%d\\n\"",NULL,NULL,NULL,NULL,NULL,"__global int* x","","*x",""}, //Global,constant, memory region {"\"%d\\n\"",NULL,NULL,NULL,NULL,NULL,"constant int* x","","*x",""}, //Local memory region {"\"%+d\\n\"",NULL,NULL,NULL,NULL,NULL,"","local int x;\n x= (int)3;\n","x",""}, //Private memory region {"\"%i\\n\"",NULL,NULL,NULL,NULL,NULL,"","private int x;\n x = (int)-1;\n","x",""}, //Address of void * from global memory region {"\"%p\\n\"",NULL,NULL,NULL,NULL,NULL,"__global void* x,__global intptr_t* xAddr","","x","*xAddr = (intptr_t)x;\n"} }; //------------------------------------------------------------------------------- // Lookup table -[string] address space -correct buffer | //------------------------------------------------------------------------------- std::vector correctAddrSpace = { "2","2","+3","-1","" }; //------------------------------------------------------------------------------- //Test case for address space | //------------------------------------------------------------------------------- testCase testCaseAddrSpace = { TYPE_ADDRESS_SPACE, correctAddrSpace, printAddrSpaceGenParameters, NULL }; //------------------------------------------------------------------------------- //All Test cases | //------------------------------------------------------------------------------- std::vector allTestCase = {&testCaseInt,&testCaseFloat,&testCaseFloatLimits,&testCaseOctal,&testCaseUnsigned,&testCaseHexadecimal,&testCaseChar,&testCaseString,&testCaseVector,&testCaseAddrSpace}; //----------------------------------------- // Check functions //----------------------------------------- size_t verifyOutputBuffer(char *analysisBuffer,testCase* pTestCase,size_t testId,cl_ulong pAddr) { int terminatePos = strlen(analysisBuffer); if(terminatePos > 0) { analysisBuffer[terminatePos - 1] = '\0'; } //Convert analysis buffer to long for address space if(pTestCase->_type == TYPE_ADDRESS_SPACE && strcmp(pTestCase->_genParameters[testId].addrSpacePAdd,"")) { char analysisBufferTmp[ANALYSIS_BUFFER_SIZE]; if(strstr(analysisBuffer,"0x") == NULL) // Need to prepend 0x to ASCII number before calling strtol. strcpy(analysisBufferTmp,"0x"); else analysisBufferTmp[0]='\0'; strcat(analysisBufferTmp,analysisBuffer); if (sizeof(long) == 8) { if(strtoul(analysisBufferTmp,NULL,0) == pAddr) return 0; } else { if(strtoull(analysisBufferTmp,NULL,0) == pAddr) return 0; } return 1; } char* exp; //Exponenent representation if((exp = strstr(analysisBuffer,"E+")) != NULL || (exp = strstr(analysisBuffer,"e+")) != NULL || (exp = strstr(analysisBuffer,"E-")) != NULL || (exp = strstr(analysisBuffer,"e-")) != NULL) { char correctExp[3]={0}; strncpy(correctExp,exp,2); char* eCorrectBuffer = strstr((char*)pTestCase->_correctBuffer[testId].c_str(),correctExp); if(eCorrectBuffer == NULL) return 1; eCorrectBuffer+=2; exp += 2; //Exponent always contains at least two digits if(strlen(exp) < 2) return 1; //Skip leading zeros in the exponent while(*exp == '0') ++exp; while(*eCorrectBuffer == '0') ++eCorrectBuffer; return strcmp(eCorrectBuffer,exp); } if(!strcmp(pTestCase->_correctBuffer[testId].c_str(),"inf")) return strcmp(analysisBuffer,"inf")&&strcmp(analysisBuffer,"infinity")&&strcmp(analysisBuffer,"1.#INF00")&&strcmp(analysisBuffer,"Inf"); if(!strcmp(pTestCase->_correctBuffer[testId].c_str(),"nan") || !strcmp(pTestCase->_correctBuffer[testId].c_str(),"-nan")) { return strcmp(analysisBuffer,"nan")&&strcmp(analysisBuffer,"-nan")&&strcmp(analysisBuffer,"1.#IND00")&&strcmp(analysisBuffer,"-1.#IND00")&&strcmp(analysisBuffer,"NaN")&&strcmp(analysisBuffer,"nan(ind)")&&strcmp(analysisBuffer,"nan(snan)")&&strcmp(analysisBuffer,"-nan(ind)"); } return strcmp(analysisBuffer,pTestCase->_correctBuffer[testId].c_str()); } static void intRefBuilder(printDataGenParameters& params, char* refResult, const size_t refSize) { snprintf(refResult, refSize, params.genericFormat, atoi(params.dataRepresentation)); } static void floatRefBuilder(printDataGenParameters& params, char* refResult, const size_t refSize) { snprintf(refResult, refSize, params.genericFormat, strtof(params.dataRepresentation, NULL)); } static void octalRefBuilder(printDataGenParameters& params, char* refResult, const size_t refSize) { const unsigned long int data = strtoul(params.dataRepresentation, NULL, 10); snprintf(refResult, refSize, params.genericFormat, data); } static void unsignedRefBuilder(printDataGenParameters& params, char* refResult, const size_t refSize) { const unsigned long int data = strtoul(params.dataRepresentation, NULL, 10); snprintf(refResult, refSize, params.genericFormat, data); } static void hexRefBuilder(printDataGenParameters& params, char* refResult, const size_t refSize) { const unsigned long int data = strtoul(params.dataRepresentation, NULL, 0); snprintf(refResult, refSize, params.genericFormat, data); } /* Generate reference results. Results are only generated for test cases that can easily be generated by using CPU printf. If that is not the case, results are constants that have been hard-coded. */ void generateRef(const cl_device_id device) { int fd = -1; char _refBuffer[ANALYSIS_BUFFER_SIZE]; const cl_device_fp_config fpConfig = get_default_rounding_mode(device); const RoundingMode hostRound = get_round(); RoundingMode deviceRound; // Map device rounding to CTS rounding type // get_default_rounding_mode supports RNE and RTZ if (fpConfig == CL_FP_ROUND_TO_NEAREST) { deviceRound = kRoundToNearestEven; } else if (fpConfig == CL_FP_ROUND_TO_ZERO) { deviceRound = kRoundTowardZero; } else { assert(false && "Unreachable"); } // Loop through all test cases for (auto &caseToTest: allTestCase) { /* Cases that have a NULL function pointer already have their reference results as they're constant and hard-coded */ if (caseToTest->printFN == NULL) continue; // Make sure the reference result is empty assert(caseToTest->_correctBuffer.size() == 0); // Loop through each input for (auto ¶ms: caseToTest->_genParameters) { char refResult[ANALYSIS_BUFFER_SIZE]; // Set CPU rounding mode to match that of the device set_round(deviceRound, caseToTest->dataType); // Generate the result caseToTest->printFN(params, refResult, ARRAY_SIZE(refResult)); // Restore the original CPU rounding mode set_round(hostRound, kfloat); // Save the reference result caseToTest->_correctBuffer.push_back(refResult); } } }