/* parses range-resp-spec and inits spec, returns true on success */
static int
httpHdrRangeRespSpecParseInit(HttpHdrRangeSpec * spec, const char *field, int flen)
{
const char *p;
assert(spec);
spec->offset = spec->length = range_spec_unknown;
if (flen < 2)
return 0;
/* is spec given ? */
if (*field == '*')
return 1;
/* check format, must be %d-%d */
if (!((p = strchr(field, '-')) && (p - field < flen))) {
debug(68, 2) ("invalid (no '-') resp-range-spec near: '%s'\n", field);
return 0;
}
/* parse offset */
if (!httpHeaderParseSize(field, &spec->offset))
return 0;
p++;
/* do we have last-pos ? */
if (p - field < flen) {
squid_off_t last_pos;
if (!httpHeaderParseSize(p, &last_pos))
return 0;
spec->length = size_diff(last_pos + 1, spec->offset);
}
/* we managed to parse, check if the result makes sence */
if (known_spec(spec->length) && !spec->length) {
debug(68, 2) ("invalid range (%ld += %ld) in resp-range-spec near: '%s'\n",
(long int) spec->offset, (long int) spec->length, field);
return 0;
}
return 1;
}
/* fills "absent" positions in range specification based on response body size
* returns true if the range is still valid
* range is valid if its intersection with [0,length-1] is not empty
*/
static int
httpHdrRangeSpecCanonize(HttpHdrRangeSpec * spec, size_t clen)
{
debug(64, 5) ("httpHdrRangeSpecCanonize: have: [%d, %d) len: %d\n",
spec->offset, spec->offset + spec->length, spec->length);
if (!known_spec(spec->offset)) /* suffix */
spec->offset = size_diff(clen, spec->length);
else if (!known_spec(spec->length)) /* trailer */
spec->length = size_diff(clen, spec->offset);
/* we have a "range" now, adjust length if needed */
assert(known_spec(spec->length));
assert(known_spec(spec->offset));
spec->length = size_min(size_diff(clen, spec->offset), spec->length);
/* check range validity */
debug(64, 5) ("httpHdrRangeSpecCanonize: done: [%d, %d) len: %d\n",
spec->offset, spec->offset + spec->length, spec->length);
return spec->length > 0;
}
/* parses range-spec and returns new object on success */
static HttpHdrRangeSpec *
httpHdrRangeSpecParseCreate(const char *field, int flen)
{
HttpHdrRangeSpec spec =
{range_spec_unknown, range_spec_unknown};
const char *p;
if (flen < 2)
return NULL;
/* is it a suffix-byte-range-spec ? */
if (*field == '-') {
if (!httpHeaderParseSize(field + 1, &spec.length))
return NULL;
} else
/* must have a '-' somewhere in _this_ field */
if (!((p = strchr(field, '-')) || (p - field >= flen))) {
debug(64, 2) ("ignoring invalid (missing '-') range-spec near: '%s'\n", field);
return NULL;
} else {
if (!httpHeaderParseSize(field, &spec.offset))
return NULL;
p++;
/* do we have last-pos ? */
if (p - field < flen) {
ssize_t last_pos;
if (!httpHeaderParseSize(p, &last_pos))
return NULL;
spec.length = size_diff(last_pos + 1, spec.offset);
}
}
/* we managed to parse, check if the result makes sence */
if (known_spec(spec.length) && !spec.length) {
debug(64, 2) ("ignoring invalid (zero length) range-spec near: '%s'\n", field);
return NULL;
}
return httpHdrRangeSpecDup(&spec);
}
/*
* Due to the different sizes and distributions of the data between pvfmm and elemental, we need to calculate how much data and which data is going to be sent to each plave
*/
int comp_alltoall_sizes(const std::vector<int> &input_sizes, const std::vector<int> &output_sizes, std::vector<int> &sendcnts, std::vector<int> &sdispls, std::vector<int> &recvcnts, std::vector<int> &rdispls, MPI_Comm comm){
int rank, size;
MPI_Comm_size(comm, &size);
MPI_Comm_rank(comm, &rank);
// compute size differences
std::vector<int> size_diff(size);
#pragma omp parallel for
for(int i=0;i<size;i++){
size_diff[i] = input_sizes[i] - output_sizes[i];
}
// first we compute the sendcnts
sendcnts.clear();
sendcnts.resize(size);
std::fill(sendcnts.begin(),sendcnts.end(),0);
for(int i=0;i<size;i++){
for(int j=0;j<size;j++){
if(rank == i && i == j) sendcnts[j] = (output_sizes[j] < input_sizes[j]) ? output_sizes[j] : input_sizes[j];
else{ // then we can take away from this one
if((size_diff[i] >= 0) && size_diff[j] < 0){
int snd = std::min(abs(size_diff[j]),abs(size_diff[i]));
size_diff[i] -= snd;
size_diff[j] += snd;
if(i == rank){
sendcnts[j] = snd;
}
}
}
}
}
// reset the difference array
#pragma omp parallel for
for(int i=0;i<size;i++){
size_diff[i] = input_sizes[i] - output_sizes[i];
}
recvcnts.clear();
recvcnts.resize(size);
std::fill(recvcnts.begin(),recvcnts.end(),0);
for(int i=0;i<size;i++){
for(int j=0;j<size;j++){
if(rank == i && i == j) recvcnts[j] = (output_sizes[j] < input_sizes[j]) ? output_sizes[j] : input_sizes[j];
else{ // then we can take away from this one
if((size_diff[i] < 0) && size_diff[j] > 0){
int recv = std::min(abs(size_diff[j]),abs(size_diff[i]));
size_diff[i] += recv;
size_diff[j] -= recv;
if(i == rank){
recvcnts[j] = recv;
}
}
}
}
}
sdispls = sendcnts;
ex_scan(sdispls);
rdispls = recvcnts;
ex_scan(rdispls);
/*
if(!rank){
for(int i=0;i<size;i++) std::cout << input_sizes[i] << " ";
std::cout << std::endl;
for(int i=0;i<size;i++) std::cout << output_sizes[i] << " ";
std::cout << std::endl;
for(int i=0;i<size;i++) std::cout << sendcnts[i] << " ";
std::cout << std::endl;
for(int i=0;i<size;i++) std::cout << recvcnts[i] << " ";
std::cout << std::endl;
for(int i=0;i<size;i++) std::cout << sdispls[i] << " ";
std::cout << std::endl;
for(int i=0;i<size;i++) std::cout << rdispls[i] << " ";
std::cout << std::endl;
}
*/
return 0;
}
