/**
* @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;
}
