uint32_t NormalUart::Send(uint32_t *Data, uint32_t Length)
{
SendHeader(&mH);
for (uint32_t i = 0; i < Length; ++i){
SendInt(&mH,Data[i]);
}
ChangeEndian(Data,Length*sizeof(uint32_t));
crcInit();
crc checksum = crcFast((unsigned char*)Data,Length*sizeof(uint32_t));
//ChangeEndian(&checksum,1);
SendInt(&mH,checksum);
return Length;
}
//Sends the actual message
bool Server::SendString(int ID, std::string & _string)
{
if(_string.find("InitChess") != std::string::npos)
{
if (!SendPacketType(ID, P_GameStateChange))
return false;
}
else if(_string.find("MOVE:") != std::string::npos)
{
if (!SendPacketType(ID, P_ChessMove))
return false;
}
else
{
if (!SendPacketType(ID, P_ChatMessage))
return false;
}
int bufferlength = _string.size();
if (!SendInt(ID, bufferlength))
return false;
int RetnCheck = send(players[FindClient(ID)].connection, _string.c_str(), bufferlength, NULL);
if (RetnCheck == SOCKET_ERROR)
return false;
return true;
}
void convb(uint8_t name){
uint16_t i;
int32_t val = 0;
ADCSRA |= _BV(ADSC);while(ADCSRA & _BV(ADSC));
ADCSRA |= _BV(ADSC);while(ADCSRA & _BV(ADSC));
for(i=0;i<1024;i++){
ADCSRA |= _BV(ADSC);while(ADCSRA & _BV(ADSC));
uint16_t v = ADC;
if(v>=512){
v = 1024 - v;
val -= v;
}
else
{
val += v;
}
}
val = val >> 6;
SerialSend(name);SerialSend(':');
if(val<0){
val = - val;
SerialSend('-');
}
else
{
SerialSend(' ');
}
SendInt(val,10);SerialSend(' ');
}
bool s13WXWServer::SendIntToAll (int iInt, std::vector<unsigned int> aryExcept)
{
unsigned int uiSocketsLength = aryClientSockets.size ();
for (unsigned int uiIdx = 0; uiIdx < uiSocketsLength; uiIdx++)
{
bool bContinue = false;
for (unsigned int uiJdx = 0; uiJdx < aryExcept.size (); uiJdx++)
{
if (uiIdx == aryExcept.at (uiJdx))
{
bContinue = true;
break;
}
}
if (bContinue == true)
continue;
if (SendInt (aryClientSockets.at (uiIdx), iInt) == false)
continue;
}
return (true);
}
void * myAlloc (void *ud, void *ptr, size_t osize,size_t nsize) {
#ifdef ALLOC_DEBUG
if (g_allocDebug){
SendString("myAlloc- ptr:");
SendUint((unsigned int)ptr);
SendString(" osize:");
SendInt(osize);
SendString(" nsize:");
SendInt(nsize);
}
#endif
if (nsize == 0) {
portFree(ptr);
#ifdef ALLOC_DEBUG
if (g_allocDebug){
SendString(" (free)");
SendCrlf();
}
#endif
return NULL;
}
else{
void *newPtr;
if (osize != nsize){
newPtr = portRealloc(ptr, nsize);
}
else{
newPtr = ptr;
}
#ifdef ALLOC_DEBUG
if (g_allocDebug){
if (ptr != newPtr){
SendString(" newPtr:");
SendUint((unsigned int)newPtr);
}
else{
SendString(" (same)");
}
SendCrlf();
}
#endif
lastPointer = (unsigned int)newPtr;
return newPtr;
}
}
static Bool
SendTerminal(
NETFILE *fp,
SessionData *data)
{
unsigned char c;
char wname[SIZE_LONGNAME+1];
LargeByteString *scrdata;
int i;
ENTER_FUNC;
SendPacketClass(fp,WFC_HEADER); ON_IO_ERROR(fp,badio);
dbgmsg("send DATA");
SendString(fp,data->hdr->user); ON_IO_ERROR(fp,badio);
SendString(fp,data->hdr->window); ON_IO_ERROR(fp,badio);
SendString(fp,data->hdr->widget); ON_IO_ERROR(fp,badio);
SendChar (fp,data->hdr->puttype); ON_IO_ERROR(fp,badio);
dbgprintf("window = [%s]",data->hdr->window);
SendInt(fp,data->w.sp); ON_IO_ERROR(fp,badio);
for (i=0;i<data->w.sp;i++) {
SendChar(fp,data->w.s[i].puttype);ON_IO_ERROR(fp,badio);
SendString(fp,data->w.s[i].window);ON_IO_ERROR(fp,badio);
}
while (1) {
c = RecvPacketClass(fp); ON_IO_ERROR(fp,badio);
switch (c) {
case WFC_DATA:
dbgmsg(">DATA");
RecvnString(fp,SIZE_LONGNAME,wname);ON_IO_ERROR(fp,badio);
if ((scrdata = GetScreenData(data,wname)) != NULL) {
dbgmsg("send OK");
SendPacketClass(fp,WFC_OK); ON_IO_ERROR(fp,badio);
SendLBS(fp,scrdata); ON_IO_ERROR(fp,badio);
} else {
dbgmsg("send NODATA");
SendPacketClass(fp,WFC_NODATA); ON_IO_ERROR(fp,badio);
}
dbgmsg("<DATA");
break;
case WFC_DONE:
dbgmsg("DONE");
return TRUE;
case WFC_END:
dbgmsg("END");
return FALSE;
default:
Warning("[%s] session failure packet [%X]",data->hdr->uuid,c);
dbgprintf("c = [%X]\n",c);
return FALSE;
}
}
Warning("does not reach");
LEAVE_FUNC;
return FALSE;
badio:
Warning("[%s] session recv failure",data->hdr->uuid);
LEAVE_FUNC;
return FALSE;
}
IndexServerConn::IndexServerConn(const std::string &addr, int port)
{
DPRINT(INFO, "Contacting index server at %s ...",addr.c_str());
if(!ConnectTo( addr, port))
return;
SendInt((int)TS_MSG_VERSION);
SendStr("WIS");
}
static void
Run(SqueakPlugin *plugin)
{
if (plugin->pid || !plugin->nswindow || !plugin->srcUrl ||plugin->failureUrl)
return;
plugin->pid= fork();
if (plugin->pid == -1) {
perror("Squeak fork() failed");
plugin->pid= 0;
return;
}
DPRINT("NP: fork() -> %i\n", plugin->pid);
if (plugin->pid == 0) {
char tmp1[16], tmp2[16];
plugin->argv[2]= NPN_StrDup(DisplayString(plugin->display));
sprintf(tmp1, "%i", plugin->pipes[SQUEAK_READ]);
plugin->argv[4]= NPN_StrDup(tmp1);
sprintf(tmp2, "%i", plugin->pipes[SQUEAK_WRITE]);
plugin->argv[5]= NPN_StrDup(tmp2);
DPRINT("NP(child): Running Squeak VM with arguments\n");
{
int i;
for (i= 1; i<plugin->argc; i++)
DPRINT(" %s\n", plugin->argv[i]);
}
/* this is from the XLib manual ... */
if ((fcntl(ConnectionNumber(plugin->display), F_SETFD, FD_CLOEXEC)) == -1)
DPRINT("NP: Cannot disinherit X connection fd\n");
DPRINT("NP(child): trying %s\n", plugin->vmName);
execv(plugin->vmName, plugin->argv);
/* ~/.npsqueak/npsqueakrun could not be executed */
strcpy(plugin->vmName, SYSTEM_BIN_DIR "/" NPSQUEAKRUN);
NPN_MemFree(plugin->argv[0]);
plugin->argv[0]= NPN_StrDup(plugin->vmName);
DPRINT("NP(child): trying %s\n", plugin->vmName);
execv(plugin->vmName, plugin->argv);
/* npsqueakrun could not be executed either */
fprintf(stderr, "Squeak Plugin: running \"%s\"\n", plugin->vmName);
perror("Squeak execv() failed");
_exit(1);
} else {
/* establish communication via command pipes */
XtAppContext app= XtDisplayToApplicationContext(plugin->display);
plugin->input= XtAppAddInput(app,
plugin->pipes[PLUGIN_READ],
(XtPointer) XtInputReadMask,
(XtInputCallbackProc) InputCallback,
plugin);
/* send browser window */
DPRINT("NP: Sending browser window=0x%X\n", plugin->nswindow);
SendInt(plugin, plugin->nswindow);
}
}
static void
DeliverFile(SqueakPlugin *plugin, int id, const char* fname)
{
int ok= fname != NULL;
DPRINT("NP: Send RECEIVE_DATA id=%i state=%i\n", id, ok);
errno= 0;
SendInt(plugin, CMD_RECEIVE_DATA);
SendInt(plugin, id);
SendInt(plugin, ok);
if (ok) {
int length= strlen(fname);
SendInt(plugin, length);
Send(plugin, fname, length);
}
if (errno)
perror("Squeak Plugin (StreamAsFile)");
}
bool Server::SendString(int ID, std::string & _string)
{
if (!SendPacketType(ID, P_ChatMessage)) //Send packet type: Chat Message, If sending packet type fails...
return false; //Return false: Failed to send string
int bufferlength = _string.size(); //Find string buffer length
if (!SendInt(ID, bufferlength)) //Send length of string buffer, If sending buffer length fails...
return false; //Return false: Failed to send string buffer length
if (!sendall(ID, (char*)_string.c_str(), bufferlength)) //Try to send string buffer... If buffer fails to send,
return false; //Return false: Failed to send string buffer
return true; //Return true: string successfully sent
}
static void
SetWindow(SqueakPlugin *plugin, Window window, int width, int height)
{
DPRINT("NP: SetWindow(0x%X, %i@%i)\n", window, width, height);
if (plugin->nswindow == window) {
XResizeWindow(plugin->display, plugin->nswindow, width, height);
} else {
/* New window */
plugin->nswindow= window;
SetUpWindow(plugin);
if (plugin->sqwindow) {
DPRINT("NP: Reparenting to plugin window 0x%X\n", plugin->nswindow);
XReparentWindow(plugin->display, plugin->sqwindow, plugin->nswindow, 0, 0);
XMapWindow(plugin->display, plugin->sqwindow);
/* notify Squeak */
SendInt(plugin, CMD_BROWSER_WINDOW);
SendInt(plugin, plugin->nswindow);
}
}
if (plugin->sqwindow)
XResizeWindow(plugin->display, plugin->sqwindow, width, height);
}
uint32_t NormalUart::Init(
char * Device,
const uint32_t TimeoutMS,
const uint32_t Baudrate,
char * IPAddr)
{
uint32_t succ = UartInit(Device,Baudrate,&mH);
SetTimeoutMs(TimeoutMS);
if (succ != 0) {
SendInt(&mH,0xAAAAAAAA);
}
return succ;
}
extern MonObjectType
RequestNewBLOB(
NETFILE *fp,
int mode)
{
MonObjectType obj;
ENTER_FUNC;
obj = GL_OBJ_NULL;
RequestBLOB(fp,BLOB_CREATE); ON_IO_ERROR(fp,badio);
SendInt(fp,mode); ON_IO_ERROR(fp,badio);
if ( RecvPacketClass(fp) == BLOB_OK ) {
obj = RecvObject(fp); ON_IO_ERROR(fp,badio);
}
badio:
LEAVE_FUNC;
return (obj);
}
static Bool
SendCommit_Redirect(
DBG_Struct *dbg)
{
Bool rc = TRUE;
if ( dbg->fpLog == NULL ) {
return rc;
}
SendPacketClass(dbg->fpLog,RED_COMMIT); ON_IO_ERROR(dbg->fpLog,badio);
SendInt(dbg->fpLog, dbg->ticket_id); ON_IO_ERROR(dbg->fpLog,badio);
if ( RecvPacketClass(dbg->fpLog) != RED_OK ) {
badio:
rc = FALSE;
Warning("Redirect Commit error (%d)", dbg->ticket_id);
}
return rc;
}
static Bool
SendVeryfyData_Redirect(
DBG_Struct *dbg)
{
Bool rc = FALSE;
if ( (dbg->fpLog != NULL)
&& ( dbg->redirectData != NULL)
&& ( LBS_Size(dbg->redirectData) > 0 ) ) {
LBS_EmitEnd(dbg->checkData);
LBS_EmitEnd(dbg->redirectData);
SendPacketClass(dbg->fpLog,RED_DATA); ON_IO_ERROR(dbg->fpLog,badio);
SendInt(dbg->fpLog, dbg->ticket_id); ON_IO_ERROR(dbg->fpLog,badio);
SendLBS(dbg->fpLog,dbg->checkData); ON_IO_ERROR(dbg->fpLog,badio);
SendLBS(dbg->fpLog,dbg->redirectData); ON_IO_ERROR(dbg->fpLog,badio);
}
rc = SendCommit_Redirect(dbg);
badio:
return rc;
}
extern void
AbortDB_Redirect(
DBG_Struct *dbg)
{
ENTER_FUNC;
if ( dbg->redirect == NULL )
return;
if ( dbg->fpLog != NULL ) {
SendPacketClass(dbg->fpLog,RED_ABORT); ON_IO_ERROR(dbg->fpLog,badio);
SendInt(dbg->fpLog, dbg->ticket_id); ON_IO_ERROR(dbg->fpLog,badio);
}
if ( dbg->redirectData != NULL ) {
LBS_EmitStart(dbg->redirectData);
LBS_EmitStart(dbg->checkData);
}
badio:
LEAVE_FUNC;
}
TError SendZero() const { return SendInt(0); }
main (int argc, char **argv)
{
/* declaration of variables */
FILE *fp; /* file pointer */
char *auxChar; /* auxiliar character */
char *modelFile = " "; /* elastic model file */
/* THICK - RHO - VP - QP - VS - QS */
int i, k, iProc, iR; /* counters */
int initF, lastF; /* initial and final frequencies */
int apl_pid; /* PVM process id control */
int nSamplesOrig; /* time series length */
int die; /* flag used to kill processes */
int pid; /* process id */
int nProc; /* number of processes */
int processControl; /* monitoring PVM start */
int *processes; /* array with process ids */
int FReceived; /* number of frequencies processed */
int nFreqProc; /* number of frequencies per process */
int nFreqPart; /* number of frequency partitions */
int **statusFreq; /* monitors processed frequencies */
int FInfo[2]; /* frequency delimiters */
int **procInfo; /* frequency limits for each processor */
float wallcpu; /* wall clock time */
float dt; /* time sampling interval */
float f; /* current frequency */
float fR; /* reference frequency */
float tMax; /* maximum recording time */
float *thick, *alpha, *beta,
*rho, *qP, *qS; /* elastic constants and thickness */
complex **freqPart; /* frequency arrays sent by the slaves */
complex **uRF, **uZF; /* final frequency components */
INFO info[1]; /* basic information for slaves */
/* Logging information */
/* CleanLog(); */
/* getting input */
initargs(argc, argv);
requestdoc(0);
if (!getparstring("model", &modelFile)) modelFile = "model";
if (!getparstring("recfile", &auxChar)) auxChar = " ";
sprintf(info->recFile, "%s", auxChar);
if (!getparint("directwave", &info->directWave)) info->directWave = 1;
if (!getparfloat("r1", &info->r1)) info->r1 = 0;
if (!getparint("nr", &info->nR)) info->nR = 148;
if (!getparfloat("dr", &info->dR)) info->dR = .025;
if (!getparfloat("zs", &info->zs)) info->zs = 0.001;
if (info->zs <= 0) info->zs = 0.001;
if (!getparfloat("u1", &info->u1)) info->u1 = 0.0002;
if (!getparfloat("u2", &info->u2)) info->u2 = 1.;
if (!getparint("nu", &info->nU)) info->nU = 1000;
if (!getparfloat("f1", &info->f1)) info->f1 = 2;
if (!getparfloat("f2", &info->f2)) info->f2 = 50;
if (!getparfloat("dt", &dt)) dt = 0.004;
if (!getparfloat("tmax", &tMax)) tMax = 8;
if (!getparfloat("F1", &info->F1)) info->F1 = 0;
if (!getparfloat("F2", &info->F2)) info->F2 = 0;
if (!getparfloat("F3", &info->F3)) info->F3 = 1;
if (!getparint("hanning", &info->hanningFlag)) info->hanningFlag = 0;
if (!getparfloat("wu", &info->percU)) info->percU = 5; info->percU /= 100;
if (!getparfloat("ww", &info->percW)) info->percW = 5; info->percW /= 100;
if (!getparfloat("fr", &fR)) fR = 1; info->wR = 2 * PI * fR;
if (!getparfloat("tau", &info->tau)) info->tau = 50;
if (!getparint("nproc", &nProc)) nProc = 1;
if (!getparint("nfreqproc", &nFreqProc) || nProc == 1) nFreqProc = 0;
if (!getparint("verbose", &info->verbose)) info->verbose = 0;
/* how many layers */
fp = fopen(modelFile,"r");
if (fp == NULL)
err("No model file!\n");
info->nL = 0;
while (fscanf(fp, "%f %f %f %f %f %f\n",
&f, &f, &f, &f, &f, &f) != EOF)
info->nL++;
info->nL--;
fclose(fp);
if (info->verbose)
fprintf(stderr,"Number of layers in model %s : %d\n",
modelFile, info->nL + 1);
/* if specific geometry, count number of receivers */
fp = fopen(info->recFile, "r");
if (fp != NULL)
{
info->nR = 0;
while (fscanf(fp, "%f\n", &f) != EOF)
info->nR++;
}
fclose(fp);
/* memory allocation */
alpha = alloc1float(info->nL + 1);
beta = alloc1float(info->nL + 1);
rho = alloc1float(info->nL + 1);
qP = alloc1float(info->nL + 1);
qS = alloc1float(info->nL + 1);
thick = alloc1float(info->nL + 1);
processes = alloc1int(nProc);
procInfo = alloc2int(2, nProc);
/* reading the file */
fp = fopen(modelFile,"r");
if (info->verbose)
fprintf(stderr,"Thickness rho vP qP vS qS\n");
for (i = 0; i < info->nL + 1; i++)
{
fscanf(fp, "%f %f %f %f %f %f\n", &thick[i], &rho[i], &alpha[i],
&qP[i], &beta[i], &qS[i]);
if (info->verbose)
fprintf(stderr," %7.4f %4.3f %3.2f %5.1f %3.2f %5.1f\n",
thick[i], rho[i], alpha[i], qP[i], beta[i], qS[i]);
}
fclose(fp);
/* computing frequency interval */
info->nSamples = NINT(tMax / dt) + 1;
nSamplesOrig = info->nSamples;
info->nSamples = npfar(info->nSamples);
/* slowness increment */
info->dU = (info->u2 - info->u1) / (float) info->nU;
/* computing more frequency related quatities */
tMax = dt * (info->nSamples - 1);
info->dF = 1. / (tMax);
f = info->dF;
while (f < info->f1) f += info->dF;
info->f1 = f;
while (f < info->f2) f += info->dF;
info->f2 = f;
initF = NINT(info->f1 / info->dF);
lastF = NINT(info->f2 / info->dF);
info->nF = lastF - initF + 1;
if (info->nF%2 == 0)
{
info->nF++;
lastF++;
}
/* attenuation of wrap-around */
info->tau = log(info->tau) / tMax;
if (info->tau > TAUMAX)
info->tau = TAUMAX;
if (info->verbose)
fprintf(stderr, "Discrete frequency range to model: [%d, %d]\n",
initF, lastF);
if (nFreqProc == 0)
nFreqProc = NINT((float) info->nF / (float) nProc + .5);
else
while (nFreqProc > info->nF) nFreqProc /= 2;
nFreqPart = NINT((float) info->nF / (float) nFreqProc + .5);
/* memory allocation for frequency arrays */
uRF = alloc2complex(info->nSamples / 2 + 1, info->nR);
uZF = alloc2complex(info->nSamples / 2 + 1, info->nR);
freqPart = alloc2complex(nFreqProc, info->nR);
statusFreq = alloc2int(3, nFreqPart);
/* defining frequency partitions */
for (k = initF, i = 0; i < nFreqPart; i++, k += nFreqProc)
{
statusFreq[i][0] = k;
statusFreq[i][1] = MIN(k + nFreqProc - 1, lastF);
statusFreq[i][2] = 0;
}
if (info->verbose)
fprintf(stderr, "Starting communication with PVM\n");
/* starting communication with PVM */
if ((apl_pid = pvm_mytid()) < 0)
{
err("Error enrolling master process");
/* exit(-1); */
}
fprintf(stderr, "Starting %d slaves ... ", nProc);
processControl = CreateSlaves(processes, PROCESS, nProc);
if (processControl != nProc)
{
err("Problem starting Slaves (%s)\n", PROCESS);
/* exit(-1); */
}
fprintf(stderr, " Ready \n");
info->nFreqProc = nFreqProc;
/* Broadcasting all processes common information */
BroadINFO(info, 1, processes, nProc, GENERAL_INFORMATION);
if (info->verbose) {
fprintf(stderr, "Broadcasting model information to all slaves\n");
fflush(stderr);
}
/* sending all profiles */
BroadFloat(thick, info->nL + 1, processes, nProc, THICKNESS);
BroadFloat(rho, info->nL + 1, processes, nProc, DENSITY);
BroadFloat(alpha, info->nL + 1, processes, nProc, ALPHA);
BroadFloat(qP, info->nL + 1, processes, nProc, QALPHA);
BroadFloat(beta, info->nL + 1, processes, nProc, BETA);
BroadFloat(qS, info->nL + 1, processes, nProc, QBETA);
/* freeing memory */
free1float(thick);
free1float(rho);
free1float(alpha);
free1float(qP);
free1float(beta);
free1float(qS);
/* sending frequency partitions for each process */
for (iProc = 0; iProc < nProc; iProc++)
{
FInfo[0] = statusFreq[iProc][0];
FInfo[1] = statusFreq[iProc][1];
if (info->verbose) {
fprintf(stderr,
"Master sending frequencies [%d, %d] out of %d to slave %d [id:%d]\n"
,FInfo[0], FInfo[1], info->nF, iProc, processes[iProc]);
fflush(stderr);
}
procInfo[iProc][0] = FInfo[0]; procInfo[iProc][1] = FInfo[1];
SendInt(FInfo, 2, processes[iProc], FREQUENCY_LIMITS);
statusFreq[iProc][2] = 1;
}
/* waiting modelled frequencies */
/* master process will send more frequencies if there's more work to do */
/* measuring elapsed time */
wallcpu = walltime();
/* reseting frequency counter */
FReceived = 0;
while (FOREVER)
{
pid = RecvCplx(freqPart[0], info->nR * nFreqProc, -1,
FREQUENCY_PARTITION_VERTICAL);
/* finding the frequency limits of this process */
iProc = 0;
while (pid != processes[iProc])
iProc++;
/* copying into proper place of the total frequency array */
for (iR = 0; iR < info->nR; iR++)
{
for (k = 0, i = procInfo[iProc][0]; i <= procInfo[iProc][1]; i++, k++)
{
uZF[iR][i] = freqPart[iR][k];
}
}
pid = RecvCplx(freqPart[0], info->nR * nFreqProc, -1,
FREQUENCY_PARTITION_RADIAL);
/* finding the frequency limits of this process */
iProc = 0;
while (pid != processes[iProc])
iProc++;
/* copying into proper place of the total frequency array */
for (iR = 0; iR < info->nR; iR++)
{
for (k = 0, i = procInfo[iProc][0]; i <= procInfo[iProc][1]; i++, k++)
{
uRF[iR][i] = freqPart[iR][k];
}
}
/* summing frequencies that are done */
FReceived += procInfo[iProc][1] - procInfo[iProc][0] + 1;
if (info->verbose)
fprintf(stderr, "Master received %d frequencies, remaining %d\n",
FReceived, info->nF - FReceived);
/* if (FReceived >= info->nF) break; */
/* defining new frequency limits */
i = 0;
while (i < nFreqPart && statusFreq[i][2])
i++;
if (i < nFreqPart)
{
/* there is still more work to be done */
/* tell this process to not die */
die = 0;
SendInt(&die, 1, processes[iProc], DIE);
FInfo[0] = statusFreq[i][0];
FInfo[1] = statusFreq[i][1];
if (info->verbose)
fprintf(stderr,
"Master sending frequencies [%d, %d] to slave %d\n",
FInfo[0], FInfo[1], processes[iProc]);
procInfo[iProc][0] = FInfo[0]; procInfo[iProc][1] = FInfo[1];
SendInt(FInfo, 2, processes[iProc], FREQUENCY_LIMITS);
statusFreq[i][2] = 1;
}
else
{
/* tell this process to die since there is no more work to do */
if (info->verbose)
fprintf(stderr, "Master ''killing'' slave %d\n", processes[iProc]);
die = 1;
SendInt(&die, 1, processes[iProc], DIE);
}
/* a check to get out the loop */
if (FReceived >= info->nF) break;
}
if (info->verbose)
fprintf(stderr, "Master ''killing'' remaining slaves\n");
/* getting elapsed time */
wallcpu = walltime() - wallcpu;
fprintf(stderr, "Wall clock time = %f seconds\n", wallcpu);
/* going to time domain */
memset( (void *) &trZ, (int) '\0', sizeof(trZ));
memset( (void *) &trR, (int) '\0', sizeof(trR));
trZ.dt = dt * 1000000;
trZ.ns = nSamplesOrig;
trR.dt = dt * 1000000;
trR.ns = nSamplesOrig;
/* z component */
for (iR = 0; iR < info->nR; iR++)
{
trZ.tracl = iR + 1;
/* inverse FFT */
pfacr(1, info->nSamples, uZF[iR], trZ.data);
for (i = 0; i < info->nSamples; i++)
{
/* compensating for the complex frequency */
trZ.data[i] *= exp(info->tau * i * dt);
}
puttr(&trZ);
}
/* r component */
for (iR = 0; iR < info->nR; iR++)
{
trR.tracl = info->nR + iR + 1;
/* inverse FFT */
pfacr(1, info->nSamples, uRF[iR], trR.data);
for (i = 0; i < info->nSamples; i++)
{
/* compensating for the complex frequency */
trR.data[i] *= exp(info->tau * i * dt);
}
puttr(&trR);
}
return(EXIT_SUCCESS);
}
int QueryByNo(int no){
SendInt(fifo_ctstat, no);
int shmid = GetInt(fifo_shstat);
printf ( "%d memory = %d \n", no, shmid );
return shmid;
}
void gradient(float *grad)
{
/* declaration of variables */
int i, iF, iR, iProc, iDer, iL, iU, offset;
/* counters */
int FReceived; /* number of frequencies processed */
int die; /* die processor flag */
int apl_pid; /* PVM process id control */
int pid; /* process id */
int masterId; /* master id */
int processControl; /* monitoring PVM start */
int FInfo[2]; /* frequency delimiters */
float wallcpu; /* wall clock time */
float *gradPart; /* partition of gradients */
complex **resCDPart; /* partition of resCD */
/* Clean up log files */
CleanLog();
/* Reseting synchronization flags */
for (i = 0; i < nFreqPart; i++)
{
statusFreq[i][2] = 0;
}
/* allocating some memory */
gradPart = alloc1float(numberPar * limRange);
for (i = 0; i < numberPar * limRange; i++)
{
grad[i] = 0;
}
fprintf(stderr, "Starting communication with PVM for derivatives\n");
/* starting communication with PVM */
if ((apl_pid = pvm_mytid()) < 0)
{
pvm_perror("Error enrolling master process");
exit(-1);
}
processControl = CreateSlaves(processes, PROCESS_FRECHET, nProc);
if (processControl != nProc)
{
fprintf(stderr,"Problem starting PVM daemons\n");
exit(-1);
}
/* converting to velocities */
if (IMPEDANCE)
{
for (i = 0; i < info->nL + 1; i++)
{
alpha[i] /= rho[i];
beta[i] /= rho[i];
}
}
/* Broadcasting all processes common information */
BroadINFO(info, 1, processes, nProc, GENERAL_INFORMATION);
/* sending all profiles */
BroadFloat(thick, info->nL + 1, processes, nProc, THICKNESS);
BroadFloat(rho, info->nL + 1, processes, nProc, DENSITY);
BroadFloat(alpha, info->nL + 1, processes, nProc, ALPHAS);
BroadFloat(qP, info->nL + 1, processes, nProc, QALPHA);
BroadFloat(beta, info->nL + 1, processes, nProc, BETAS);
BroadFloat(qS, info->nL + 1, processes, nProc, QBETA);
/* sending frequency partitions for each process */
for (iProc = 0; iProc < nProc; iProc++)
{
FInfo[0] = statusFreq[iProc][0];
FInfo[1] = statusFreq[iProc][1];
if (info->verbose)
fprintf(stderr,
"Master sending frequencies [%d, %d] out of %d to slave Frechet %d [id:%d]\n", FInfo[0], FInfo[1], info->nF, iProc, processes[iProc]);
procInfo[iProc][0] = FInfo[0];
procInfo[iProc][1] = FInfo[1];
SendInt(FInfo, 2, processes[iProc], FREQUENCY_LIMITS);
statusFreq[iProc][2] = 1;
/* and sending the appropriate correlation chunk */
/* allocating some memory */
resCDPart = alloc2complex(FInfo[1] - FInfo[0] + 1, info->nR);
for (iR = 0; iR < info->nR; iR++)
{
for (i = 0, iF = FInfo[0]; iF <= FInfo[1]; iF++, i++)
{
resCDPart[iR][i] = resCD[iR][iF - initF];
/* fprintf(stderr, "iR %d iF %d [%f %f]\n",
iR, iF, resCDPart[iR][i].r, resCDPart[iR][i].i);*/
}
}
/* sending frequency partition to the slave process */
SendCplx(resCDPart[0], (FInfo[1] - FInfo[0] + 1) * info->nR,
processes[iProc], COVARIANCE_PARTITION);
free2complex(resCDPart);
}
/* waiting modelled frequencies */
/* master process will send more frequencies if there's more work to do */
/* measuring elapsed time */
wallcpu = walltime();
/* reseting frequency counter */
FReceived = 0;
while (FOREVER)
{
pid = RecvFloat(gradPart, info->numberPar * info->limRange, -1,
PARTIAL_GRADIENT);
/* finding the frequency limits of this process */
/* DD
fprintf(stderr, "Master finding the frequency limits of this process\n");
*/
iProc = 0;
while (pid != processes[iProc])
iProc++;
/* stacking gradient */
for (i = 0; i < info->numberPar * info->limRange; i++)
{
grad[i] += gradPart[i];
/* DD
fprintf(stderr, "i %d grad %f gradPart %f\n", i, grad[i], gradPart[i]);*/
}
/* summing frequencies that are done */
FReceived += procInfo[iProc][1] - procInfo[iProc][0] + 1;
if (info->verbose)
fprintf(stderr, "Master received %d frequencies, remaining %d\n",
FReceived, info->nF - FReceived);
/* defining new frequency limits */
i = 0;
while (i < nFreqPart && statusFreq[i][2])
i++;
/* DD
fprintf(stderr, "i %d nFreqPart %d\n", i, nFreqPart);*/
if (i < nFreqPart)
{
/* there is still more work to be done */
/* tell this process to not die */
die = 0;
SendInt(&die, 1, processes[iProc], DIE);
FInfo[0] = statusFreq[i][0];
FInfo[1] = statusFreq[i][1];
if (info->verbose)
fprintf(stderr,
"Master sending frequencies [%d, %d] to slave %d\n",
FInfo[0], FInfo[1], processes[iProc]);
procInfo[iProc][0] = FInfo[0];
procInfo[iProc][1] = FInfo[1];
SendInt(FInfo, 2, processes[iProc], FREQUENCY_LIMITS);
statusFreq[i][2] = 1;
/* sending covariance partition */
/* allocating some memory */
resCDPart = alloc2complex(FInfo[1] - FInfo[0] + 1, info->nR);
for (iR = 0; iR < info->nR; iR++)
{
for (i = 0, iF = FInfo[0]; iF <= FInfo[1]; iF++, i++)
{
resCDPart[iR][i] = resCD[iR][iF - initF];
}
}
/* sending frequency partition to the slave process */
SendCplx(resCDPart[0], (FInfo[1] - FInfo[0] + 1) * info->nR,
processes[iProc], COVARIANCE_PARTITION);
free2complex(resCDPart);
}
else
{
/* tell this process to die since there is no more work to do */
if (info->verbose)
fprintf(stderr, "Master ''killing'' slave %d\n", processes[iProc]);
die = 1;
SendInt(&die, 1, processes[iProc], DIE);
}
/* a check to get out the loop */
if (FReceived >= info->nF) break;
}
/* getting elapsed time */
wallcpu = walltime() - wallcpu;
fprintf(stderr, "Frechet derivative wall clock time = %f seconds\n\n",
wallcpu);
/* back to impedances*/
if (IMPEDANCE)
{
for (i = 0; i < info->nL + 1; i++)
{
alpha[i] *= rho[i];
beta[i] *= rho[i];
}
}
/* finally the gradient, the 2 is due Parseval */
for (iDer = 0; iDer < numberPar * limRange; iDer++)
{
grad[iDer] *= 2 / (float) (nTotalSamples * oFNorm);
}
/* getting gradient in impedance domain */
if (IMPEDANCE)
{
offset = 0;
for (i = lim[0], iL = 0; iL < limRange; iL++, i++)
{
if (vpFrechet)
{
grad[iL] /= rho[i];
offset = limRange;
}
if (vsFrechet)
{
grad[iL + offset] /= rho[i];
offset += limRange;
}
if (rhoFrechet)
{
grad[iL + offset] = - alpha[i] * grad[iL] -
beta[i] * grad[iL + limRange] + grad[iL + 2 * limRange];
}
}
}
if (PRIOR)
{
auxm1 = 1. / (float) (numberPar * limRange); /* normalization */
/* considering the regularization or model covariance term */
for (i = 0; i < limRange; i++)
{
for (offset = i, iL = 0; iL < limRange; iL++)
{
iU = 0;
if (vpFrechet)
{
grad[iL] += (alpha[i + lim[0]] - alphaMean[i + lim[0]]) *
CMvP[offset] * auxm1;
iU = limRange; /* used as offset in gradient vector */
}
if (vsFrechet)
{
grad[iL + iU] += (beta[i + lim[0]] - betaMean[i + lim[0]]) *
CMvS[offset] * auxm1;
iU += limRange;
}
if (rhoFrechet)
{
grad[iL + iU] += (rho[i + lim[0]] - rhoMean[i + lim[0]]) *
CMrho[offset] * auxm1;
}
offset += MAX(SGN0(i - iL) * (limRange - 1 - iL), 1);
}
}
}
/* normalizing gradient
normalize(grad, numberPar * limRange);*/
/* freeing memory */
free1float(gradPart);
}
int CClientThread::SendData(void)
{
if( t_send.size()==0 )
return 0;
SSendData* ldata=t_send[0];
_i32 ret;
ret=clientpipe->isWritable(CLIENT_TIMEOUT*1000)?1:0;
if(ret < 1)
{
Log("Client Timeout occured.", LL_DEBUG);
if( ldata->delbuf==true )
{
bufmgr->releaseBuffer(ldata->delbufptr);
ldata->delbuf=false;
}
t_send.erase( t_send.begin() );
delete ldata;
return -1;
}
else
{
if( ldata->bsize>0 )
{
unsigned int sent=0;
while(sent<ldata->bsize)
{
_i32 ts;
if(cmd_id==ID_GET_FILE_RESUME_HASH)
ts=(std::min)((unsigned int)(next_checkpoint-sent_bytes), ldata->bsize-sent);
else
ts=ldata->bsize;
_i32 rc=SendInt(&ldata->buffer[sent], ts);
if( rc==SOCKET_ERROR )
{
int err;
#ifdef _WIN32
err=WSAGetLastError();
#else
err=errno;
#endif
Log("SOCKET_ERROR in SendData(). BSize: "+nconvert(ldata->bsize)+" WSAGetLastError: "+nconvert(err), LL_DEBUG);
if( ldata->delbuf==true )
{
bufmgr->releaseBuffer(ldata->delbufptr);
ldata->delbuf=false;
}
t_send.erase( t_send.begin() );
delete ldata;
return -1;
}
else if(cmd_id==ID_GET_FILE_RESUME_HASH)
{
hash_func.update((unsigned char*)&ldata->buffer[sent], ts);
}
sent+=ts;
sent_bytes+=ts;
if(cmd_id==ID_GET_FILE_RESUME_HASH)
{
if(next_checkpoint-sent_bytes==0)
{
hash_func.finalize();
SendInt((char*)hash_func.raw_digest_int(), 16);
next_checkpoint+=c_checkpoint_dist;
if(next_checkpoint>curr_filesize)
next_checkpoint=curr_filesize;
hash_func.init();
}
}
}
}
else
{
Log("ldata is null", LL_DEBUG);
}
if( ldata->delbuf==true )
{
bufmgr->releaseBuffer( ldata->delbufptr );
ldata->delbuf=false;
}
if( ldata->last==true )
{
Log("Info: File End", LL_DEBUG);
if( t_send.size() > 1 )
{
Log("Error: Senddata exceeds 1", LL_DEBUG);
}
for(size_t i=0;i<t_send.size();++i)
{
if( t_send[i]->delbuf==true )
{
bufmgr->releaseBuffer( t_send[i]->buffer );
}
delete t_send[i];
}
t_send.clear();
return 2;
}
t_send.erase( t_send.begin() );
delete ldata;
return 1;
}
}
bool CClientThread::ProcessPacket(CRData *data)
{
uchar id;
if( data->getUChar(&id)==true )
{
switch(id)
{
case ID_GET_GAMELIST:
{
#ifdef CHECK_IDENT
std::string ident;
data->getStr(&ident);
if(!FileServ::checkIdentity(ident))
{
Log("Identity check failed -1", LL_DEBUG);
return false;
}
#endif
hFile=0;
std::vector<std::wstring> games=get_maps();
Log("Sending game list", LL_DEBUG);
EnableNagle();
CWData data;
data.addUChar( ID_GAMELIST );
data.addUInt( (unsigned int)games.size() );
stack.Send(clientpipe, data);
for(size_t i=0;i<games.size();++i)
{
std::string version;
std::wstring udir;
version=getFile(wnarrow(map_file(games[i]+L"\\version.uri",true,&udir)));
if( udir!=L"" )
games[i]+=L"|"+udir;
std::string game=Server->ConvertToUTF8(games[i]);
stack.Send(clientpipe, (char*)game.c_str(), game.size() );
stack.Send(clientpipe, (char*)version.c_str(), version.size() );
}
Log("done.", LL_DEBUG);
DisableNagle();
}break;
case ID_GET_FILE_RESUME:
case ID_GET_FILE:
case ID_GET_FILE_RESUME_HASH:
{
std::string s_filename;
if(data->getStr(&s_filename)==false)
break;
#ifdef CHECK_IDENT
std::string ident;
data->getStr(&ident);
if(!FileServ::checkIdentity(ident))
{
Log("Identity check failed -2", LL_DEBUG);
return false;
}
#endif
std::wstring o_filename=Server->ConvertToUnicode(s_filename);
_i64 start_offset=0;
bool offset_set=data->getInt64(&start_offset);
Log("Sending file "+Server->ConvertToUTF8(o_filename), LL_DEBUG);
std::wstring filename=map_file(o_filename);
Log("Mapped name: "+Server->ConvertToUTF8(filename), LL_DEBUG);
if(filename.empty())
{
char ch=ID_BASE_DIR_LOST;
int rc=SendInt(&ch, 1);
if(rc==SOCKET_ERROR)
{
Log("Error: Socket Error - DBG: Send BASE_DIR_LOST -1", LL_DEBUG);
return false;
}
Log("Info: Base dir lost -1", LL_DEBUG);
break;
}
cmd_id=id;
if( id==ID_GET_FILE_RESUME_HASH )
{
hash_func.init();
}
#ifdef _WIN32
if(filename.size()<2 || (filename[0]!='\\' && filename[1]!='\\' ) )
{
filename=L"\\\\?\\"+filename;
}
if(bufmgr==NULL)
{
bufmgr=new CBufMgr(NBUFFERS,READSIZE);
}
#endif
#ifndef LINUX
#ifndef BACKUP_SEM
hFile=CreateFileW(filename.c_str(), FILE_READ_DATA, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED|FILE_FLAG_SEQUENTIAL_SCAN, NULL);
#else
hFile=CreateFileW(filename.c_str(), FILE_READ_DATA, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED|FILE_FLAG_BACKUP_SEMANTICS|FILE_FLAG_SEQUENTIAL_SCAN, NULL);
#endif
if(hFile == INVALID_HANDLE_VALUE)
{
hFile=NULL;
#ifdef CHECK_BASE_PATH
std::wstring basePath=map_file(getuntil(L"/",o_filename)+L"/");
if(!isDirectory(basePath))
{
char ch=ID_BASE_DIR_LOST;
int rc=SendInt(&ch, 1);
if(rc==SOCKET_ERROR)
{
Log("Error: Socket Error - DBG: Send BASE_DIR_LOST", LL_DEBUG);
return false;
}
Log("Info: Base dir lost", LL_DEBUG);
break;
}
#endif
char ch=ID_COULDNT_OPEN;
int rc=SendInt(&ch, 1);
if(rc==SOCKET_ERROR)
{
Log("Error: Socket Error - DBG: Send COULDNT OPEN", LL_DEBUG);
return false;
}
Log("Info: Couldn't open file", LL_DEBUG);
break;
}
currfilepart=0;
sendfilepart=0;
sent_bytes=start_offset;
LARGE_INTEGER filesize;
GetFileSizeEx(hFile, &filesize);
curr_filesize=filesize.QuadPart;
next_checkpoint=start_offset+c_checkpoint_dist;
if(next_checkpoint>curr_filesize)
next_checkpoint=curr_filesize;
if( offset_set==false || id==ID_GET_FILE_RESUME || id==ID_GET_FILE_RESUME_HASH )
{
CWData data;
data.addUChar(ID_FILESIZE);
data.addUInt64(filesize.QuadPart);
int rc=SendInt(data.getDataPtr(), data.getDataSize());
if(rc==SOCKET_ERROR)
{
Log("Error: Socket Error - DBG: SendSize", LL_DEBUG);
CloseHandle(hFile);
hFile=NULL;
return false;
}
}
if(filesize.QuadPart==0)
{
CloseHandle(hFile);
hFile=NULL;
break;
}
for(_i64 i=start_offset;i<filesize.QuadPart && stopped==false;i+=READSIZE)
{
bool last;
if(i+READSIZE<filesize.QuadPart)
last=false;
else
{
last=true;
Log("Reading last file part", LL_DEBUG);
}
while(bufmgr->nfreeBufffer()==0 && stopped==false)
{
int rc;
SleepEx(0,true);
rc=SendData();
if(rc==-1)
{
Log("Error: Send failed in file loop -1", LL_DEBUG);
CloseThread(hFile);
}
else if(rc==0)
SleepEx(1,true);
}
if( stopped==false )
ReadFilePart(hFile, i, last);
if(FileServ::isPause() )
{
DWORD starttime=GetTickCount();
while(GetTickCount()-starttime<5000)
{
SleepEx(500,true);
int rc=SendData();
if(rc==-1)
{
Log("Error: Send failed in file pause loop -2", LL_DEBUG);
CloseThread(hFile);
}
}
}
}
while(bufmgr->nfreeBufffer()!=NBUFFERS && stopped==false)
{
SleepEx(0,true);
int rc;
rc=SendData();
if( rc==2 && bufmgr->nfreeBufffer()!=NBUFFERS )
{
Log("Error: File end and not all Buffers are free!-1", LL_WARNING);
}
if(rc==-1)
{
Log("Error: Send failed in off file loop -3", LL_DEBUG);
CloseHandle(hFile);
hFile=NULL;
break;
}
else if(rc==0)
SleepEx(1,true);
}
if( stopped==false )
{
Log("Closed file.", LL_DEBUG);
CloseHandle(hFile);
hFile=NULL;
}
#else //LINUX
hFile=open64(Server->ConvertToUTF8(filename).c_str(), O_RDONLY|O_LARGEFILE);
if(hFile == INVALID_HANDLE_VALUE)
{
#ifdef CHECK_BASE_PATH
std::wstring basePath=map_file(getuntil(L"/",o_filename)+L"/");
if(!isDirectory(basePath))
{
char ch=ID_BASE_DIR_LOST;
int rc=SendInt(&ch, 1);
if(rc==SOCKET_ERROR)
{
Log("Error: Socket Error - DBG: Send BASE_DIR_LOST", LL_DEBUG);
return false;
}
Log("Info: Base dir lost", LL_DEBUG);
break;
}
#endif
hFile=0;
char ch=ID_COULDNT_OPEN;
int rc=SendInt(&ch, 1);
if(rc==SOCKET_ERROR)
{
Log("Error: Socket Error - DBG: Send COULDNT OPEN", LL_DEBUG);
return false;
}
Log("Info: Couldn't open file", LL_DEBUG);
break;
}
currfilepart=0;
sendfilepart=0;
struct stat64 stat_buf;
fstat64(hFile, &stat_buf);
off64_t filesize=stat_buf.st_size;
curr_filesize=filesize;
if( offset_set==false || id==ID_GET_FILE_RESUME || id==ID_GET_FILE_RESUME_HASH )
{
CWData data;
data.addUChar(ID_FILESIZE);
data.addUInt64(filesize);
int rc=SendInt(data.getDataPtr(), data.getDataSize() );
if(rc==SOCKET_ERROR)
{
Log("Error: Socket Error - DBG: SendSize", LL_DEBUG);
CloseHandle(hFile);
hFile=0;
return false;
}
}
if(filesize==0)
{
CloseHandle(hFile);
hFile=0;
break;
}
off64_t foffset=start_offset;
unsigned int s_bsize=8192;
if(id==ID_GET_FILE || id==ID_GET_FILE_RESUME )
{
s_bsize=32768;
next_checkpoint=curr_filesize;
}
else
{
next_checkpoint=start_offset+c_checkpoint_dist;
if(next_checkpoint>curr_filesize)
next_checkpoint=curr_filesize;
}
char *buf=new char[s_bsize];
bool has_error=false;
while( foffset < filesize )
{
size_t count=(std::min)((size_t)s_bsize, (size_t)(next_checkpoint-foffset));
if( clientpipe==NULL && ( id==ID_GET_FILE || id==ID_GET_FILE_RESUME ) )
{
ssize_t rc=sendfile64(int_socket, hFile, &foffset, count);
if(rc>0)
{
foffset+=rc;
}
else
{
Log("Error: Reading and sending from file failed", LL_DEBUG);
CloseHandle(hFile);
delete []buf;
return false;
}
}
else
{
ssize_t rc=read(hFile, buf, count);
if(rc>0)
{
rc=SendInt(buf, rc);
if(rc==SOCKET_ERROR)
{
Log("Error: Sending data failed");
CloseHandle(hFile);
delete []buf;
return false;
}
else if(id==ID_GET_FILE_RESUME_HASH)
{
hash_func.update((unsigned char*)buf, rc);
}
foffset+=rc;
}
else
{
Log("Error: Reading from file failed", LL_DEBUG);
CloseHandle(hFile);
delete []buf;
return false;
}
if(id==ID_GET_FILE_RESUME_HASH && foffset==next_checkpoint)
{
hash_func.finalize();
SendInt((char*)hash_func.raw_digest_int(), 16);
next_checkpoint+=c_checkpoint_dist;
if(next_checkpoint>curr_filesize)
next_checkpoint=curr_filesize;
hash_func.init();
}
}
if(FileServ::isPause() )
{
Sleep(500);
}
}
CloseHandle(hFile);
delete []buf;
hFile=0;
#endif
}break;
case ID_GET_FILE_BLOCKDIFF:
{
bool b=GetFileBlockdiff(data);
if(!b)
return false;
}break;
case ID_BLOCK_REQUEST:
{
if(state==CS_BLOCKHASH)
{
Handle_ID_BLOCK_REQUEST(data);
}
}break;
}
}
if( stopped==true )
return false;
else
return true;
}
bool CClientThread::GetFileBlockdiff(CRData *data)
{
std::string s_filename;
if(data->getStr(&s_filename)==false)
return false;
#ifdef CHECK_IDENT
std::string ident;
data->getStr(&ident);
if(!FileServ::checkIdentity(ident))
{
Log("Identity check failed -2", LL_DEBUG);
return false;
}
#endif
std::wstring o_filename=Server->ConvertToUnicode(s_filename);
_i64 start_offset=0;
data->getInt64(&start_offset);
curr_hash_size=0;
data->getInt64(&curr_hash_size);
Log("Sending file "+Server->ConvertToUTF8(o_filename), LL_DEBUG);
std::wstring filename=map_file(o_filename);
Log("Mapped name: "+Server->ConvertToUTF8(filename), LL_DEBUG);
if(filename.empty())
{
char ch=ID_BASE_DIR_LOST;
int rc=SendInt(&ch, 1);
if(rc==SOCKET_ERROR)
{
Log("Error: Socket Error - DBG: Send BASE_DIR_LOST -1", LL_DEBUG);
return false;
}
Log("Info: Base dir lost -1", LL_DEBUG);
return true;
}
hash_func.init();
#ifdef _WIN32
if(filename.size()<2 || (filename[0]!='\\' && filename[1]!='\\' ) )
filename=L"\\\\?\\"+filename;
#endif
#ifdef _WIN32
#ifndef BACKUP_SEM
hFile=CreateFileW(filename.c_str(), FILE_READ_DATA, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
#else
hFile=CreateFileW(filename.c_str(), FILE_READ_DATA, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS|FILE_FLAG_SEQUENTIAL_SCAN, NULL);
#endif
#else //_WIN32
hFile=open64(Server->ConvertToUTF8(filename).c_str(), O_RDONLY|O_LARGEFILE);
#endif //_WIN32
if(hFile == INVALID_HANDLE_VALUE)
{
hFile=(HANDLE)NULL;
#ifdef CHECK_BASE_PATH
std::wstring basePath=map_file(getuntil(L"/",o_filename)+L"/");
if(!isDirectory(basePath))
{
char ch=ID_BASE_DIR_LOST;
int rc=SendInt(&ch, 1);
if(rc==SOCKET_ERROR)
{
Log("Error: Socket Error - DBG: Send BASE_DIR_LOST", LL_DEBUG);
return false;
}
Log("Info: Base dir lost", LL_DEBUG);
return true;
}
#endif
char ch=ID_COULDNT_OPEN;
int rc=SendInt(&ch, 1);
if(rc==SOCKET_ERROR)
{
Log("Error: Socket Error - DBG: Send COULDNT OPEN", LL_DEBUG);
return false;
}
Log("Info: Couldn't open file", LL_DEBUG);
return true;
}
currfilepart=0;
sendfilepart=0;
sent_bytes=0;
#ifdef _WIN32
LARGE_INTEGER filesize;
GetFileSizeEx(hFile, &filesize);
curr_filesize=filesize.QuadPart;
#else
struct stat64 stat_buf;
fstat64(hFile, &stat_buf);
curr_filesize=stat_buf.st_size;
#endif
next_checkpoint=start_offset+c_checkpoint_dist;
if(next_checkpoint>curr_filesize)
next_checkpoint=curr_filesize;
CWData sdata;
sdata.addUChar(ID_FILESIZE);
sdata.addUInt64(curr_filesize);
SendInt(sdata.getDataPtr(), sdata.getDataSize());
if(mutex==NULL)
{
mutex=Server->createMutex();
cond=Server->createCondition();
}
state=CS_BLOCKHASH;
if(chunk_send_thread_ticket==ILLEGAL_THREADPOOL_TICKET)
{
IFile * tf=Server->openFileFromHandle((void*)hFile);
if(tf==NULL)
{
Log("Could not open file from handle", LL_ERROR);
return false;
}
chunk_send_thread_ticket=Server->getThreadPool()->execute(new ChunkSendThread(this, tf, curr_hash_size) );
}
else
{
IScopedLock lock(mutex);
update_file=Server->openFileFromHandle((void*)hFile);
if(update_file==NULL)
{
Log("Could not open update file from handle", LL_ERROR);
}
cond->notify_all();
}
hFile=(HANDLE)NULL;
return true;
}
float modeling()
{
/* declaration of variables */
FILE *fp; /* to report results */
int iF, iF1, iR, offset, iT1, iT2, iS, iProc, i, k;
/* counters */
int wL; /* window length */
int die; /* die processor flag */
int FReceived; /* number of frequencies processed */
int apl_pid; /* PVM process id control */
int pid; /* process id */
int processControl; /* monitoring PVM start */
int FInfo[2]; /* frequency delimiters */
float wallcpu; /* wall clock time */
float oF; /* value of the objective function */
float residue; /* data residue */
float wdw; /* windowing purposes */
float *buffer, *bufferRCD; /* auxiliary buffers */
/* upgoing waves */
complex **dataS; /* synthethics in the frequency domain */
complex *bufferC; /* auxiliary buffer */
complex **freqPart; /* frequency arrays sent by the slaves */
/* Clean up log files */
CleanLog();
/* Reseting synchronization flags */
for (i = 0; i < nFreqPart; i++)
{
statusFreq[i][2] = 0;
}
/* allocating some memory */
dataS = alloc2complex(info->nF, info->nR);
buffer = alloc1float(info->nSamples);
bufferRCD = alloc1float(info->nSamples);
bufferC = alloc1complex(info->nSamples / 2 + 1);
freqPart = alloc2complex(info->nFreqProc, info->nR);
/* reseting */
for (iF = 0; iF < info->nSamples / 2 + 1; iF++)
bufferC[iF] = zeroC;
for (iS = 0; iS < info->nSamples; iS++)
{
buffer[iS] = 0; bufferRCD[iS] = 0;
}
/* DD
fprintf(stderr, "nF -> %d\n", info->nF);*/
fprintf(stderr, "Starting communication with PVM for modeling\n");
/* starting communication with PVM */
if ((apl_pid = pvm_mytid()) < 0)
{
pvm_perror("Error enrolling master process");
exit(-1);
}
processControl = CreateSlaves(processes, PROCESS_MODELING, nProc);
if (processControl != nProc)
{
fprintf(stderr,"Problem starting PVM daemons\n");
exit(-1);
}
/* converting to velocities */
if (IMPEDANCE)
{
for (i = 0; i < info->nL + 1; i++)
{
alpha[i] /= rho[i];
beta[i] /= rho[i];
}
}
/* Broadcasting all processes common information */
BroadINFO(info, 1, processes, nProc, GENERAL_INFORMATION);
/* sending all profiles */
BroadFloat(thick, info->nL + 1, processes, nProc, THICKNESS);
BroadFloat(rho, info->nL + 1, processes, nProc, DENSITY);
BroadFloat(alpha, info->nL + 1, processes, nProc, ALPHAS);
BroadFloat(qP, info->nL + 1, processes, nProc, QALPHA);
BroadFloat(beta, info->nL + 1, processes, nProc, BETAS);
BroadFloat(qS, info->nL + 1, processes, nProc, QBETA);
/* sending frequency partitions for each process */
for (iProc = 0; iProc < nProc; iProc++)
{
FInfo[0] = statusFreq[iProc][0];
FInfo[1] = statusFreq[iProc][1];
if (info->verbose)
fprintf(stderr,
"Master sending frequencies [%d, %d] out of %d to slave Modeling %d [id:%d]\n", FInfo[0], FInfo[1], info->nF, iProc, processes[iProc]);
procInfo[iProc][0] = FInfo[0];
procInfo[iProc][1] = FInfo[1];
SendInt(FInfo, 2, processes[iProc], FREQUENCY_LIMITS);
statusFreq[iProc][2] = 1;
}
/* waiting modelled frequencies */
/* master process will send more frequencies if there's more work to do */
/* measuring elapsed time */
wallcpu = walltime();
/* reseting frequency counter */
FReceived = 0;
while (FOREVER)
{
pid = RecvCplx(freqPart[0], info->nR * info->nFreqProc, -1,
FREQUENCY_PARTITION);
/* finding the frequency limits of this process */
/* DD
fprintf(stderr, "Master finding the frequency limits of this process\n");
*/
iProc = 0;
while (pid != processes[iProc])
iProc++;
/* DD
fprintf(stderr, "iProc %d pid %d\n", iProc, pid);*/
/* copying into proper place of the total frequency array */
for (iR = 0; iR < info->nR; iR++)
{
for (k = 0, i = procInfo[iProc][0]; i <= procInfo[iProc][1]; i++, k++)
{
dataS[iR][i - initF] = freqPart[iR][k];
}
}
/* summing frequencies that are done */
FReceived += procInfo[iProc][1] - procInfo[iProc][0] + 1;
if (info->verbose)
fprintf(stderr, "Master received %d frequencies, remaining %d\n",
FReceived, info->nF - FReceived);
/* defining new frequency limits */
i = 0;
while (i < nFreqPart && statusFreq[i][2])
i++;
/* DD
fprintf(stderr, "i %d nFreqPart %d\n", i, nFreqPart);*/
if (i < nFreqPart)
{
/* there is still more work to be done */
/* tell this process to not die */
die = 0;
SendInt(&die, 1, processes[iProc], DIE);
FInfo[0] = statusFreq[i][0];
FInfo[1] = statusFreq[i][1];
if (info->verbose)
fprintf(stderr, "Master sending frequencies [%d, %d] to slave %d\n", FInfo[0], FInfo[1], processes[iProc]);
procInfo[iProc][0] = FInfo[0];
procInfo[iProc][1] = FInfo[1];
SendInt(FInfo, 2, processes[iProc], FREQUENCY_LIMITS);
statusFreq[i][2] = 1;
}
else
{
/* tell this process to die since there is no more work to do */
if (info->verbose)
fprintf(stderr, "Master ''killing'' slave %d\n", processes[iProc]);
die = 1;
SendInt(&die, 1, processes[iProc], DIE);
}
/* a check to get out the loop */
if (FReceived >= info->nF) break;
}
/* quitting PVM */
EndOfMaster();
/* getting elapsed time */
wallcpu = walltime() - wallcpu;
fprintf(stderr, "Modeling wall clock time = %f seconds\n",
wallcpu);
/* back to impedances*/
if (IMPEDANCE)
{
for (i = 0; i < info->nL + 1; i++)
{
alpha[i] *= rho[i];
beta[i] *= rho[i];
}
}
/* computing the objective function for the time window */
for (oF = 0, residue = 0, iR = 0; iR < info->nR; iR++)
{
/* windowing as it was done to the input data */
iT1 = NINT(info->f1 / info->dF);
iT2 = NINT(info->f2 / info->dF);
wL = info->nF * PERC_WINDOW / 2;
wL = 2 * wL + 1;
for (iS = 0, iF = 0; iF < info->nSamples / 2 + 1; iF++)
{
if (iF < iT1 || iF >= iT2)
{
bufferC[iF] = cmplx(0, 0);
}
else if (iF - iT1 < (wL - 1) / 2)
{
wdw = .42 - .5 * cos(2 * PI * (float) iS / ((float) (wL - 1))) +
.08 * cos(4 * PI * (float) iS / ((float) (wL - 1)));
bufferC[iF].r = dataS[iR][iF - iT1].r * wdw;
bufferC[iF].i = dataS[iR][iF - iT1].i * wdw;
iS++;
}
else if (iF - iT1 >= info->nF - (wL - 1) / 2)
{
iS++;
wdw = .42 - .5 * cos(2 * PI * (float) iS / ((float) (wL - 1))) +
.08 * cos(4 * PI * (float) iS / ((float) (wL - 1)));
bufferC[iF].r = dataS[iR][iF - iT1].r * wdw;
bufferC[iF].i = dataS[iR][iF - iT1].i * wdw;
}
else
{
bufferC[iF] = dataS[iR][iF - iT1];
}
}
/* going to time domain */
/* DD
fprintf(stderr, "going to time domain \n");*/
pfacr(1, info->nSamples, bufferC, buffer);
/* muting ? */
if (MUTE)
{
for (iS = 0; iS <= NINT(t1Mute[iR] / dt); iS++)
{
buffer[iS] = 0;
}
}
/* and computing data misfit and likelihood function */
iS = NINT(t1 / dt);
for (iT1 = 0; iT1 < nDM; iT1++)
{
bufferRCD[iT1 + iS] = 0;
for (offset = iT1, iT2 = 0; iT2 < nDM; iT2++)
{
bufferRCD[iT1 + iS] +=
(buffer[iT2 + iS] - dataObs[iR][iT2]) * CD[offset];
offset += MAX(SGN0(iT1 - iT2) * (nDM - 1 - iT2), 1);
}
oF += (buffer[iT1 + iS] - dataObs[iR][iT1]) * bufferRCD[iT1 + iS];
residue += (buffer[iT1 + iS] - dataObs[iR][iT1]) *
(buffer[iT1 + iS] - dataObs[iR][iT1]);
/* DD
fprintf(stdout, "%d %f %f %f %f %f %d %f %f\n",
nTotalSamples, oF, dt, auxm1,
info->tau, residue, iT1, buffer[iT1],
dataObs[iR][iT1 - NINT(t1 / dt)]); */
}
/* windowing bufferRCD */
iT1 = NINT(t1 / dt);
iT2 = NINT(t2 / dt);
wL = nDM * PERC_WINDOW / 2;
wL = 2 * wL + 1;
for (iS = 0, iF = 0; iF < info->nSamples; iF++)
{
if (iF < iT1 || iF >= iT2)
{
bufferRCD[iF] = 0;
}
else if (iF - iT1 < (wL - 1) / 2)
{
wdw =
.42 - .5 * cos(2 * PI * (float) iS / ((float) (wL - 1))) +
.08 * cos(4 * PI * (float) iS / ((float) (wL - 1)));
bufferRCD[iF] *= wdw;
iS++;
}
else if (iF - iT1 >= nDM - (wL - 1) / 2)
{
iS++;
wdw =
.42 - .5 * cos(2 * PI * (float) iS / ((float) (wL - 1))) +
.08 * cos(4 * PI * (float) iS / ((float) (wL - 1)));
bufferRCD[iF] *= wdw;
}
}
/* going back to Fourier domain */
pfarc(-1, info->nSamples, bufferRCD, bufferC);
for (iF1 = 0, iF = NINT(info->f1 / info->dF);
iF <= NINT(info->f2 / info->dF); iF++, iF1++)
{
resCD[iR][iF1] = bufferC[iF];
}
}
/* considering the .5 factor of the exponent of the Gaussian */
/* and normalizing the likelihood by the number of samples */
oF /= (2 * nTotalSamples);
/* freeing some memory */
/* allocating some memory */
free2complex(dataS);
free1float(buffer);
free1float(bufferRCD);
free1complex(bufferC);
free2complex(freqPart);
/* considering the regularizaton or model covariance term */
if (PRIOR)
{
auxm1 = 1. / (float) (numberPar * limRange); /* normalization */
for (auxm2 = 0, iF = 0; iF < limRange; iF++)
{
for (offset = iF, iF1 = 0; iF1 < limRange; iF1++)
{
if (vpFrechet)
{
auxm2 += (alpha[iF + lim[0]] - alphaMean[iF + lim[0]]) *
CMvP[offset] * auxm1 *
(alpha[iF1 + lim[0]] - alphaMean[iF1 + lim[0]]);
}
if (vsFrechet)
{
auxm2 += (beta[iF + lim[0]] - betaMean[iF + lim[0]]) *
CMvS[offset] * auxm1 *
(beta[iF1 + lim[0]] - betaMean[iF1 + lim[0]]);
}
if (rhoFrechet)
{
auxm2 += (rho[iF + lim[0]] - rhoMean[iF + lim[0]]) *
CMrho[offset] * auxm1 *
(rho[iF1 + lim[0]] - rhoMean[iF1 + lim[0]]);
}
offset += MAX(SGN0(iF - iF1) * (limRange - 1 - iF1), 1);
}
}
}
/* getting normalization factor */
fp = fopen("report", "a");
fprintf(fp,"-----------------------\n");
if (modCount == 0)
{
oFNorm = oF;
fprintf(fp,">> Normalization constant for objective function: %f <<\n",
oFNorm);
}
/* normalizing residue */
residue /= (nTotalSamples);
if (!DATACOV && noiseVar == 0) noiseVar = residue / 10.;
if (PRIOR)
{
fprintf(fp,
"residue at iteration [%d] : Data residue variance %f , Noise variance %f , Likelihood %f , Prior %f\n",
modCount, residue, noiseVar, oF / oFNorm, auxm2 / oFNorm);
}
else
{
fprintf(fp,"residue at iteration [%d] : Data residue variance %f , Noise variance %f , Likelihood %f , No Prior\n", modCount, residue, noiseVar, oF / oFNorm);
}
/* checking if we reached noise variance with the data residue */
if (residue / noiseVar <= 1)
{
/* DATA IS FIT, stop the procedure */
fprintf(fp, "[][][][][][][][][][][][][][][][][][][][]\n");
fprintf(fp, "DATA WAS FIT UP TO 1 VARIANCE!\n");
fprintf(fp, "[][][][][][][][][][][][][][][][][][][][]\n");
exit(0);
}
/* adding Likelihood and Prior */
if (PRIOR) oF += auxm2 / 2;
fprintf(fp,"TOTAL residue at iteration [%d] : %f\n",
modCount, oF / oFNorm);
fprintf(fp,"-----------------------\n");
fclose(fp);
/* returning objective function value */
return(oF / oFNorm);
}
