/**
* @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;
}
char * unpackRILResponseFull(char *inRsp, size_t length, int32_t *out_ril_errno, int32_t *out_token)
{
Parcel p;
int32_t type;
int32_t token;
status_t status;
RIL_Errno e;
p.setData((uint8_t *) inRsp, length);
// status checked at end
status = p.readInt32(&type);
if (type == RESPONSE_UNSOLICITED) {
status = p.readInt32(&token);
LOGD("unpackRILResponse: Discard UNSOLICITED response:%d\n",token);
return NULL;
}
status = p.readInt32(&token);
if (out_token != NULL) {
*out_token = token;
}
status = p.readInt32((int32_t *)&e);
if ((NO_ERROR != status)) {
LOGE("unpackRILResponse: Error!");
return NULL;
}
if (out_ril_errno != NULL) {
*out_ril_errno = e;
LOGD("unpackRILResponse: Return error cause: %d", e);
}
if (RIL_E_SUCCESS != e) {
return NULL;
}
return unpackStrings(p);
}
