void SphereForceFieldOpenCL3f_addForce(unsigned int size, GPUSphere* sphere, _device_pointer penetration, _device_pointer f, const _device_pointer x, const _device_pointer v)
{
int BSIZE = gpu::opencl::OpenCLMemoryManager<float>::BSIZE;
DEBUG_TEXT( "SphereForceFieldOpenCL3f_addForce");
BARRIER(f,__FILE__,__LINE__);
float4 sc(sphere->center.x(),sphere->center.y(),sphere->center.z(),0.0);
float4 sd(sphere->r ,sphere->stiffness,sphere->damping,0.0);
SphereForceField_CreateProgramWithFloat();
SphereForceFieldOpenCL3f_addForce_kernel->setArg<float4>(0,&sc);
SphereForceFieldOpenCL3f_addForce_kernel->setArg<float4>(1,&sd);
SphereForceFieldOpenCL3f_addForce_kernel->setArg<_device_pointer>(2,&penetration);
SphereForceFieldOpenCL3f_addForce_kernel->setArg<_device_pointer>(3,&f);
SphereForceFieldOpenCL3f_addForce_kernel->setArg<_device_pointer>(4,&x);
SphereForceFieldOpenCL3f_addForce_kernel->setArg<_device_pointer>(5,&v);
size_t local_size[1];
local_size[0]=BSIZE;
size_t work_size[1];
work_size[0]=((size%BSIZE)==0)?size:BSIZE*(size/BSIZE+1);
SphereForceFieldOpenCL3f_addForce_kernel->execute(0,1,NULL,work_size,local_size); //note: num_device = const = 0
BARRIER(f,__FILE__,__LINE__);
}
void SpatialGridContainer_findCellRange(int cellBits, int index0, float /*cellWidth*/, int nbPoints, const gpu::opencl::_device_pointer particleHash8,gpu::opencl::_device_pointer cellRange,gpu::opencl::_device_pointer cellGhost)
{
DEBUG_TEXT("SpatialGridContainer_findCellRange");
BARRIER(particleHash8,__FILE__,__LINE__);
opencl::myopenclMemsetDevice(0,cellRange, 0, ((1<<cellBits)+1)*sizeof(int));
opencl::myopenclMemsetDevice(0,cellGhost, 0, ((1<<cellBits))*sizeof(int));
//if(show_hash==NULL)show_hash = new ShowVector("debug_hash");
//show_hash->addOpenCLVector<int>(cellRange,(1<<cellBits)+1);
int BSIZE = gpu::opencl::OpenCLMemoryManager<float>::BSIZE;
SpatialGridContainer_CreateProgramWithFloat();
if(SpatialGridContainer3f_findCellRange_kernel==NULL)SpatialGridContainer3f_findCellRange_kernel
= new OpenCLKernel(SpatialGridContainerOpenCLFloat_program,"findCellRangeD");
SpatialGridContainer3f_findCellRange_kernel->setArg<int>(0,&index0);
SpatialGridContainer3f_findCellRange_kernel->setArg<_device_pointer>(1,&particleHash8);
SpatialGridContainer3f_findCellRange_kernel->setArg<_device_pointer>(2,&cellRange);
SpatialGridContainer3f_findCellRange_kernel->setArg<_device_pointer>(3,&cellGhost);
int nbPoints8 = nbPoints*8;
SpatialGridContainer3f_findCellRange_kernel->setArg<int>(4,&nbPoints8);
size_t local_size[1];
local_size[0]=BSIZE;
size_t work_size[1];
work_size[0]=((nbPoints8%BSIZE)==0)?nbPoints8:BSIZE*(nbPoints8/BSIZE+1);
SpatialGridContainer3f_findCellRange_kernel->execute(0,1,NULL,work_size,local_size); //note: num_device = const = 0
DEBUG_TEXT("~SpatialGridContainer_findCellRange");
BARRIER(particleHash8,__FILE__,__LINE__);
}
void SpatialGridContainer3f_computeHash(int cellBits, float cellWidth, int nbPoints,gpu::opencl::_device_pointer particleIndex8,gpu::opencl::_device_pointer particleHash8, const gpu::opencl::_device_pointer x)
{
DEBUG_TEXT("SpatialGridContainer3f_computeHash");
BARRIER(x,__FILE__,__LINE__);
int BSIZE = gpu::opencl::OpenCLMemoryManager<float>::BSIZE;
SpatialGridContainer_CreateProgramWithFloat();
/* float posx[nbPoints*3];
opencl::myopenclEnqueueReadBuffer(0,posx,x.m,0,nbPoints*3*sizeof(float));
std::cout << "\n###" << nbPoints << "\n";
for(int i=0;i<nbPoints*3;i++)std::cout << posx[i] << ";";
std::cout << "\n\n";*/
// exit(0);
GridParams p;
p.cellWidth = cellWidth;
p.invCellWidth = 1.0f/cellWidth;
p.cellMask = (1<<cellBits)-1;
p.halfCellWidth = cellWidth*0.5f;
p.invHalfCellWidth = 2.0f/cellWidth;
/* std::cout << "p.cellWidth:" << p.cellWidth << "\tp.invCellWidth:" << p.invCellWidth << "\tp.cellMask:" << p.cellMask << "\tp.halfCellWidth:" << p.halfCellWidth << "\tp.invHalfCellWidth:" << p.invHalfCellWidth << "\n";
float d1[30];
opencl::myopenclEnqueueReadBuffer(0,d1,x.m,x.offset,30*sizeof(float));
std::cout << "x =(";
for(int i=0;i<30;i++){if(i%3==0 && i)std::cout<<") ( "; std::cout << d1[i] << " ";}
std::cout << ")\n";*/
if(SpatialGridContainer3f_computeHash_kernel==NULL)SpatialGridContainer3f_computeHash_kernel
= new OpenCLKernel(SpatialGridContainerOpenCLFloat_program,"computeHashD");
SpatialGridContainer3f_computeHash_kernel->setArg<_device_pointer>(0,&x);
SpatialGridContainer3f_computeHash_kernel->setArg<_device_pointer>(1,&particleIndex8);
int offsetIndex = particleIndex8.offset/sizeof(int);
SpatialGridContainer3f_computeHash_kernel->setArg<int>(2,&offsetIndex);
SpatialGridContainer3f_computeHash_kernel->setArg<_device_pointer>(3,&particleHash8);
SpatialGridContainer3f_computeHash_kernel->setArg<int>(4,&nbPoints);
SpatialGridContainer3f_computeHash_kernel->setArg<GridParams>(5,&p);
size_t local_size[1];
local_size[0]=BSIZE;
size_t work_size[1];
work_size[0]=((nbPoints%BSIZE)==0)?nbPoints:BSIZE*(nbPoints/BSIZE+1);
SpatialGridContainer3f_computeHash_kernel->execute(0,1,NULL,work_size,local_size); //note: num_device = const = 0
/* float pos[nbPoints*3];
opencl::myopenclEnqueueReadBuffer(0,pos,x.m,0,nbPoints*3*sizeof(float));
std::cout << "\n###" << nbPoints << "\n";
for(int i=0;i<nbPoints*3;i++){std::cout << pos[i];if(i%1024==1023)std::cout<<"\n";else std::cout<<";";}
std::cout << "\n\n";
int posx[nbPoints*8];
opencl::myopenclEnqueueReadBuffer(0,posx,particleIndex8.m,particleIndex8.offset,nbPoints*8*sizeof(int));
std::cout << "\n###" << nbPoints << "\n";
for(int i=0;i<nbPoints*8;i++){std::cout << posx[i];if(i%1024==1023)std::cout<<"\n";else std::cout<<";";}
std::cout << "\n\n";
exit(0);*/
/* opencl::myopenclEnqueueReadBuffer(0,d1,x.m,x.offset,30*sizeof(float));
std::cout << "x =(";
for(int i=0;i<30;i++){if(i%3==0 && i)std::cout<<") ( "; std::cout << d1[i] << " ";}
std::cout << ")\n";*/
DEBUG_TEXT("~SpatialGridContainer3f_computeHash");
BARRIER(x,__FILE__,__LINE__);
//NOT_IMPLEMENTED();
}
token_t parse_new_token(word_t *token)
{
token_t cls = NONE;
unsigned char *cp;
bool done = false;
/* If saved IPADDR, truncate last octet */
if ( block_on_subnets && save_class == IPADDR )
{
byte *t = xmemrchr(ipsave->u.text, '.', ipsave->leng);
if (t == NULL)
save_class = NONE;
else
{
ipsave->leng = (uint) (t - ipsave->u.text);
token_set( token, ipsave->u.text, ipsave->leng);
cls = save_class;
done = true;
}
}
while (!done) {
uint leng;
byte *text;
cls = (*lexer->yylex)();
token->leng = lexer->get_parser_token(&token->u.text);
Z(token->u.text[token->leng]); /* for easier debugging - removable */
leng = token->leng;
text = token->u.text;
if (DEBUG_TEXT(2)) {
word_puts(token, 0, dbgout);
fputc('\n', dbgout);
}
if (cls == NONE) /* End of message */
break;
switch (cls) {
case EOH: /* end of header - bogus if not empty */
if (leng > max_token_len)
continue;
if (msg_state->mime_type == MIME_MESSAGE)
mime_add_child(msg_state);
if (leng == 1)
continue;
else { /* "spc:invalid_end_of_header" */
token_copy( &yylval, nonblank_line);
done = true;
}
break;
case BOUNDARY: /* don't return boundary tokens to the user */
continue;
case VERP: /* Variable Envelope Return Path */
{
byte *st = (byte *)text;
byte *in;
byte *fst = NULL;
byte *lst = NULL;
for (in = st; *in != '\0'; in += 1) {
if (*in == '-') {
if (fst == NULL)
fst = in;
lst = in;
}
}
if (fst != NULL && lst != NULL && lst - fst > 3) {
byte *ot = fst;
*ot++ = '-';
*ot++ = '#';
for (in = lst; *in != '\0'; in += 1, ot += 1)
*ot = *in;
token->leng = leng = (uint) (ot - st);
}
Z(token->u.text[token->leng]); /* for easier debugging - removable */
}
break;
case HEADKEY:
{
if (!header_line_markup || *text == '\0')
continue;
else {
const char *delim = strchr((const char *)text, ':');
leng = (uint) (delim - (const char *)text);
if (leng > max_token_len)
continue;
token_set( &yylval, text, leng);
}
}
/*@fallthrough@*/
case TOKEN: /* ignore anything when not reading text MIME types */
if (leng < min_token_len)
continue;
/*@fallthrough@*/
case MONEY: /* 2 character money is OK */
if (leng > max_token_len)
continue;
token->u.text = text;
token->leng = leng;
if (token_prefix == NULL) {
switch (msg_state->mime_type) {
case MIME_TEXT:
case MIME_TEXT_HTML:
case MIME_TEXT_PLAIN:
case MIME_MULTIPART:
break;
case MIME_MESSAGE:
case MIME_APPLICATION:
case MIME_IMAGE:
continue;
default:
continue;
}
}
break;
case MESSAGE_ID:
/* special token; saved for formatted output, but not returned to bogofilter */
/** \bug: the parser MUST be aligned with lexer_v3.l! */
if (leng < max_token_len)
{
while (!isspace(text[0])) {
text += 1;
leng -= 1;
}
while (isspace(text[0])) {
text += 1;
leng -= 1;
}
token_set( msg_id, text, leng);
}
continue;
case QUEUE_ID:
/* special token; saved for formatted output, but not returned to bogofilter */
/** \bug: the parser MUST be aligned with lexer_v3.l! */
if (*queue_id->u.text == '\0' &&
leng < max_token_len )
{
while (isspace(text[0])) {
text += 1;
leng -= 1;
}
if (memcmp(text, "id", 2) == 0) {
text += 2;
leng -= 2;
}
while (isspace(text[0])) {
text += 1;
leng -= 1;
}
if (text[0] == '<') {
text += 1;
leng -= 1;
}
if (text[leng-1] == '>') {
leng -= 1;
}
leng = min(queue_id->leng, leng);
memcpy( queue_id->u.text, text, leng );
Z(queue_id->u.text[leng]);
}
continue;
case MESSAGE_ADDR:
{
/* trim brackets */
text += 1;
leng -= 2;
Z(text[leng]); /* for easier debugging - removable */
token_set( &yylval, text, leng);
/* if top level, no address, not localhost, .... */
if (token_prefix == w_recv &&
msg_state->parent == NULL &&
*msg_addr->u.text == '\0' &&
strcmp((char *)text, "127.0.0.1") != 0)
{
/* Not guaranteed to be the originating address of the message. */
memcpy( msg_addr->u.text, yylval.u.text, min(msg_addr->leng, yylval.leng)+D );
Z(msg_addr->u.text[yylval.leng]);
}
}
/*@fallthrough@*/
case IPADDR:
if (block_on_subnets)
{
int q1, q2, q3, q4;
/*
* Trick collected by ESR in real time during John
* Graham-Cummings's talk at Paul Graham's spam conference
* in January 2003... Some spammers know that people are
* doing recognition on spamhaus IP addresses. They use
* the fact that HTML clients normally interpret IP addresses
* by doing a simple accumulate-and-shift algorithm; they
* add large random multiples of 256 to the quads to
* mask their origin. Nuke the high bits to unmask the
* address.
*/
if (sscanf((const char *)text, "%d.%d.%d.%d", &q1, &q2, &q3, &q4) == 4)
/* safe because result string guaranteed to be shorter */
sprintf((char *)text, "%d.%d.%d.%d",
q1 & 0xff, q2 & 0xff, q3 & 0xff, q4 & 0xff);
leng = strlen((const char *)text);
token->u.text = text;
token->leng = leng;
token_copy( ipsave, token );
save_class = IPADDR;
return (cls);
}
token->u.text = text;
token->leng = leng;
break;
case NONE: /* nothing to do */
break;
case MSG_COUNT_LINE:
msg_count_file = true;
multi_token_count = 1;
header_line_markup = false;
token_prefix = NULL;
lexer = &msg_count_lexer;
if (mbox_mode) {
/* Allows processing multiple messages, **
** but only a single file. */
reader_more = msgcount_more;
}
continue;
case BOGO_LEX_LINE:
token_set( &yylval, text, leng);
done = true;
break;
}
if (DEBUG_TEXT(1)) {
word_puts(&yylval, 0, dbgout);
fputc('\n', dbgout);
}
/* eat all long words */
if (token->leng <= max_token_len)
done = true;
}
if (!msg_count_file) {
/* Remove trailing blanks */
/* From "From ", for example */
while (token->leng > 1 && token->u.text[token->leng-1] == ' ') {
token->leng -= 1;
token->u.text[token->leng] = (byte) '\0';
}
/* Remove trailing colon */
if (token->leng > 1 && token->u.text[token->leng-1] == ':') {
token->leng -= 1;
token->u.text[token->leng] = (byte) '\0';
}
if (replace_nonascii_characters) {
/* replace nonascii characters by '?'s */
for (cp = token->u.text; cp < token->u.text+token->leng; cp += 1)
*cp = casefold_table[*cp];
}
}
return(cls);
}
