/** * @brief Sorts strings. Keys are the first four characters of the string, * and values are the addresses where the strings reside in memory (stringVals) * * Takes as input an array of strings arranged as a char* array with NULL terminating * characters. This function will reformat this info into keys (first four chars) * values(pointers to string array addresses) and aligned string value array. * * * * @param[in] planHandle handle to CUDPPSortPlan * @param[in] stringVals Original string input, no need for alignment or offsets. * @param[in] d_address Pointers (in order) to each strings starting location in the stringVals array * @param[in] termC Termination character used to separate strings * @param[in] numElements number of strings * @param[in] stringArrayLength Length in uint of the size of all strings * @returns CUDPPResult indicating success or error condition * * @see cudppPlan, CUDPPConfiguration, CUDPPAlgorithm */ CUDPP_DLL CUDPPResult cudppStringSort(const CUDPPHandle planHandle, unsigned char *d_stringVals, unsigned int *d_address, unsigned char termC, size_t numElements, size_t stringArrayLength) { CUDPPStringSortPlan *plan = (CUDPPStringSortPlan*)getPlanPtrFromHandle<CUDPPStringSortPlan>(planHandle); if (plan != NULL) { if (plan->m_config.algorithm != CUDPP_SORT_STRING) return CUDPP_ERROR_INVALID_PLAN; unsigned int* packedStringVals; unsigned int *packedStringLength = (unsigned int*)malloc(sizeof(unsigned int));; calculateAlignedOffsets(d_address, plan->m_numSpaces, d_stringVals, termC, numElements, stringArrayLength); cudppScanDispatch(plan->m_spaceScan, plan->m_numSpaces, numElements+1, 1, plan->m_scanPlan); dotAdd(d_address, plan->m_spaceScan, plan->m_packedAddress, numElements+1, stringArrayLength); cudaMemcpy(packedStringLength, (plan->m_packedAddress)+numElements, sizeof(unsigned int), cudaMemcpyDeviceToHost); cudaMemcpy(plan->m_packedAddressRef, plan->m_packedAddress, sizeof(unsigned int)*numElements, cudaMemcpyDeviceToDevice); cudaMemcpy(plan->m_addressRef, d_address, sizeof(unsigned int)*numElements, cudaMemcpyDeviceToDevice); //system("PAUSE"); cudaMalloc((void**)&packedStringVals, sizeof(unsigned int)*packedStringLength[0]); packStrings(packedStringVals, d_stringVals, plan->m_keys, plan->m_packedAddress, d_address, numElements, stringArrayLength, termC); cudppStringSortDispatch(plan->m_keys, plan->m_packedAddress, packedStringVals, numElements, packedStringLength[0], termC, plan); unpackStrings(plan->m_packedAddress, plan->m_packedAddressRef, d_address, plan->m_addressRef, numElements); free(packedStringLength); cudaFree(packedStringVals); return CUDPP_SUCCESS; } else return CUDPP_ERROR_INVALID_HANDLE; }
/* * packRILcommandString * Used for packing standard AT command string to RIL command. * * IN *inStr : AT command string with NULL terminate * IN *prefix : prefix of AT response * OUT **outCmd : RAW RIL command out. Caller is responsible to free this resource. * RETUURN : Length of outCmd data. */ size_t packRILCommand(char *inStr, char *prefix, char **outCmd) { /* |Request Enum |Request Token|Number of Strings|Srings.....| * |<--4 bytes-->|<--4 bytes-->|<--- 4 bytes --->|<------ ->| */ size_t length = 0; char *cmdStr[2] = {NULL,NULL}; char *pData = NULL; Parcel p; static int s_token = 0; if ((NULL == inStr)||(NULL == outCmd)) { return 0; } cmdStr[0] = inStr; cmdStr[1] = prefix; // p.writeInt32(length); /* fake write to reserve space */ p.writeInt32(RIL_REQUEST_OEM_HOOK_STRINGS); p.writeInt32(s_token++); packStrings(p,cmdStr,2*sizeof(char *)); /* ONLY support 1 string now */ length = p.dataSize(); #if 0 offset = p.dataPosition(); /* Store data position */ p.setDataPosition(0); /* Move to the buffer pointer to head */ p.writeInt32(length - 4); /* Update data length */ p.setDataPosition(offset); /* Restore data position */ #endif /* 0 */ pData = (char *) malloc(length); if (NULL != pData) { memcpy(pData,p.data(),length); *outCmd = pData; LOGI("packRILCommand: %d bytes\n",length); printRawData((const void *) pData, length); } else { return 0; } return length; }