void cholesky_dmModel(double **m, double D_d, double d, double ref_freq,double *resx,double *resy,double *rese,int np, int nc){
double secperyear=365.25*86400.0;
double tobs=ceil((resx[np-1])-(resx[0]))/365.25;
double alpha=8.0/3.0;
D_d *=1e-12; // convert us to seconds
d*=86400.0; // convert days to seconds.
logdbg("D_d(%f) = %f (us^2)\n",d,D_d );
logdbg("ref_freq = %f (MHz)\n",ref_freq );
logmsg("Warning: cholesky DM model currently ignores ref_freq");
//power at 1 year
//Equation 12 from Keith et al. (2012)
// 0.0112 scales a structure function into a power spectrum
double pism = 0.0112 * D_d * pow(d,(-5.0/3.0)) * pow(secperyear,-1.0/3.0);
logdbg("pism(1yr^-1) = %g (yr^3)",pism);
double fc=1/tobs;
// power at fc
pism*=pow(fc,-alpha);
logdbg("pism(%lfyr^-1) = %g (yr^3)",fc,pism);
cholesky_powerlawModel(m,alpha,fc,pism,resx,resy,rese,np,nc);
}
/**
* An accelerated cholesky decomposion to form uinv in plac.
* uinv is a lower triangular, row-major, matrix.
*/
int accel_uinv(double* _m, int n){
int i,j;
double* _u=_m;
double* _uinv=_m;
double* _t=(double*)malloc(sizeof(double)*(n*(n+1))/2);
// LAPACK Cholesky factorisation.
// _u is a symetric matrix.
F77_dpotf2("L",&n,_u,&n,&i);
if(i!=0){
logerr("Error in Cholesky Decomp i=%d",i);
return i;
}
// This code taken from the LAPACK documentation
// to pack a triangular matrix.
int jc=0;
for (j=0;j<n;j++){ // cols
for (i=j;i<n;i++){ //rows
// note that at this point _u is ordered column major
// because the LAPACK routine is a FORTRAN code.
_t[jc+i-j] = _u[j*n+i];
}
jc=jc+n-j;
}
logdbg("Done CholDecomp... Inverting...",i);
F77_dtptri("L","N",&n,_t,&i);
if(i!=0){
logerr("Error in Invert i=%d",i);
return i;
}
// Unpack the triangular matrix using reverse
// of code above, but unpacking into a row-major matrix
// for C compatibility.
jc=0;
for (j=0;j<n;j++){ // cols
for (i=0; i < j; i++){
// when unpacking we need to zero out the strict upper triangle.
_u[i*n+j]=0;
}
for (i=j;i<n;i++){ //rows
// here we arange _u in row-major order
// to be C compatible on return.
_u[i*n+j]=_t[jc+i-j];
}
jc=jc+n-j;
}
free(_t);
logdbg("Done Invert.",i);
return 0;
}
void _ensure_line(std::string file, std::string line)
{
if (_file_has_line(file, line))
{
logdbg(file + " is configured.");
return;
}
logdbg("Appending to " + file + " :\n " + line);
std::ofstream f(file, std::ios_base::app | std::ios_base::out);
f << line << "\n";
}
void formBats(pulsar *psr,int npsr)
{
int i,p;
// double etatdm;
double shapiroDelay;
const char *CVS_verNum = "$Revision: 1.8 $";
if (displayCVSversion == 1) CVSdisplayVersion("formBats.C","formBats()",CVS_verNum);
logdbg("In formBats");
for (p=0;p<npsr;p++)
{
for (i=0;i<psr[p].nobs;i++)
{
// if (psr[p].obsn[i].clockCorr==0 || psr[p].obsn[i].delayCorr==0)
if (psr[p].obsn[i].delayCorr==0)
psr[p].obsn[i].bat = psr[p].obsn[i].sat;
else
{
/* ORIGINAL TEMPO calculation */
if (psr[p].calcShapiro==-1)
shapiroDelay = 0.0;
else
shapiroDelay = psr[p].obsn[i].shapiroDelaySun + psr[p].planetShapiro*
(psr[p].obsn[i].shapiroDelayVenus+
psr[p].obsn[i].shapiroDelayJupiter+psr[p].obsn[i].shapiroDelaySaturn
+psr[p].obsn[i].shapiroDelayUranus + psr[p].obsn[i].shapiroDelayNeptune);
//if(i==0){printf("Forming bat with sat = %.15g TT = %.15g TT_TB = %.15g trop = %.15g roemer = %.15g shap = %.15g tdis1 = %.15g tdis2 = %.15g\n",(double)psr[p].obsn[i].sat,(double)getCorrectionTT(psr[p].obsn+i),(double)psr[p].obsn[i].correctionTT_TB,(double)psr[p].obsn[i].troposphericDelay,(double)psr[p].obsn[i].roemer,(double)shapiroDelay,(double)psr[p].obsn[i].tdis1,(double)psr[p].obsn[i].tdis2);}
long double batcorr=getCorrectionTT(psr[p].obsn+i)/SECDAY
+ (psr[p].obsn[i].correctionTT_TB
-psr[p].obsn[i].troposphericDelay
+psr[p].obsn[i].roemer -
shapiroDelay - psr[p].obsn[i].tdis1 - psr[p].obsn[i].tdis2)/SECDAY;
psr[p].obsn[i].batCorr = batcorr;
psr[p].obsn[i].bat = psr[p].obsn[i].sat +
getCorrectionTT(psr[p].obsn+i)/SECDAY
+ (psr[p].obsn[i].correctionTT_TB
-psr[p].obsn[i].troposphericDelay
+psr[p].obsn[i].roemer -
shapiroDelay - psr[p].obsn[i].tdis1 - psr[p].obsn[i].tdis2)/SECDAY;
/* Now calculate binary barycentric arrival time (bbat) */
psr[p].obsn[i].bbat = psr[p].obsn[i].bat - (psr[p].obsn[i].shklovskii)/SECDAY;
}
}
}
logdbg("Leaving formBats");
}
int log_enqueue (int prio, const char * fmt, va_list ap)
{
int len, fwd;
char buff[MAX_MSG_SIZE];
struct logmsg * msg;
struct logmsg * lastmsg;
lastmsg = (struct logmsg *)la->tail;
if (!la->empty) {
fwd = sizeof(struct logmsg) +
strlen((char *)&lastmsg->str) * sizeof(char) + 1;
la->tail += fwd;
}
vsnprintf(buff, MAX_MSG_SIZE, fmt, ap);
len = strlen(buff) * sizeof(char) + 1;
/* not enough space on tail : rewind */
if (la->head <= la->tail &&
(len + sizeof(struct logmsg)) > (la->end - la->tail)) {
logdbg(stderr, "enqueue: rewind tail to %p\n", la->tail);
la->tail = la->start;
}
/* not enough space on head : drop msg */
if (la->head > la->tail &&
(len + sizeof(struct logmsg)) > (la->head - la->tail)) {
logdbg(stderr, "enqueue: log area overrun, drop msg\n");
if (!la->empty)
la->tail = lastmsg;
return 1;
}
/* ok, we can stage the msg in the area */
la->empty = 0;
msg = (struct logmsg *)la->tail;
msg->prio = prio;
memcpy((void *)&msg->str, buff, len);
lastmsg->next = la->tail;
msg->next = la->head;
logdbg(stderr, "enqueue: %p, %p, %i, %s\n", (void *)msg, msg->next,
msg->prio, (char *)&msg->str);
#if LOGDBG
dump_logarea();
#endif
return 0;
}
void IoEvent::set() {
#ifdef WINDOWS
SetEvent(m_handle);
#else // !WINDOWS
#if IO_EVENT_USE_POLL
if (m_ownsFDs)
write(m_pipe[1], "x", 1);
#elif IO_EVENT_USE_KQUEUE
MutexLock lock(m_mutex);
if (m_type == IoEventTypeUser && m_kqueue >= 0) {
logdbg("%p", this);
struct kevent kev[1];
EV_SET(&kev[0], m_ident, EVFILT_USER, 0, NOTE_TRIGGER, 0, 0);
int rv = kevent(m_kqueue, kev, 1, 0, 0, 0);
if (rv == -1)
logerr("Failed to set event: %s (%d)", strerror(errno), errno);
}
#endif // IO_EVENT_USE_xxx
#endif // WINDOWS
}
int Session::read_head()
{
struct msg_header tmp;
int n_read = readn(m_sockfd, (u_char*)&tmp, sizeof(struct msg_header));
if (n_read == 0)
{
return SESSION_RET_NO_DATA;
}
if (n_read < (int)sizeof(struct msg_header))
{
return -1;
}
if (tmp.version != 0x02 || tmp.msg_type > MSG_MAX || tmp.length > 16 * 1024)
{
logerr("invalid header, version:%u, msg_type:%u, length:%d\n",
tmp.version, tmp.msg_type, tmp.length);
return -1;
}
logdbg("ip:%s msg type:%d, len:%d, pid:%d\n",
get_string_ip().c_str(), tmp.msg_type, tmp.length, g_pid);
m_msg_type = (msg_type_t)tmp.msg_type;
m_msg_len = tmp.length;
return 0;
}
void IoEvent::reset() {
#ifdef WINDOWS
ResetEvent(m_handle);
#else // !WINDOWS
#if IO_EVENT_USE_POLL
if (m_ownsFDs) {
uint8_t buf;
while (read(m_pipe[0], &buf, 1) == 1)
;
}
#elif IO_EVENT_USE_KQUEUE
MutexLock lock(m_mutex);
if (m_type == IoEventTypeUser && m_kqueue >= 0) {
logdbg("%p", this);
struct kevent kev[1];
EV_SET(&kev[0], m_ident, EVFILT_USER, EV_CLEAR, 0, 0, 0);
int rv = kevent(m_kqueue, kev, 1, 0, 0, 0);
if (rv == -1)
logerr("Failed to reset event: %s (%d)", strerror(errno), errno);
}
#endif // IO_EVENT_USE_xxx
#endif // WINDOWS
}
int log_dequeue (void * buff)
{
struct logmsg * src = (struct logmsg *)la->head;
struct logmsg * dst = (struct logmsg *)buff;
struct logmsg * lst = (struct logmsg *)la->tail;
int len;
if (la->empty)
return 0;
len = strlen((char *)&src->str) * sizeof(char) +
sizeof(struct logmsg) + 1;
dst->prio = src->prio;
memcpy(dst, src, len);
if (la->tail == la->head)
la->empty = 1; /* purge the last log msg */
else {
la->head = src->next;
lst->next = la->head;
}
logdbg(stderr, "dequeue: %p, %p, %i, %s\n",
(void *)src, src->next, src->prio, (char *)&src->str);
memset((void *)src, 0, len);
return len;
}
HRESULT CDebugInfoWalker::_AddFuncToList(
_In_ CFunctionSizes & funcList,
_In_ IDiaSymbol *pSymbol,
_In_ wstring const & funcNameToMatch)
{
BSTR symName;
HRESULT hr = pSymbol->get_name(&symName);
if(hr == S_OK)
{
if(!funcNameToMatch.empty() && (wcsstr(symName, funcNameToMatch.c_str()) == nullptr))
{
// Requested for substring match but no match found
logdbg(L"Skipping: %s", symName);
SysFreeString(symName);
return S_FALSE;
}
ULONGLONG ullSize;
hr = pSymbol->get_length(&ullSize);
if(hr == S_OK)
{
funcList.addData(symName, ullSize);
}
SysFreeString(symName);
}
return hr;
}
void cholesky_readFromCovarianceFunction(double **m, char* fname,double *resx,double *resy,double *rese,int np, int nc){
int ndays = ceil((resx[np-1-nc]-resx[0])+1e-10);
double covarFunc[ndays+1];
double escaleFactor = 1.0;
int i;
FILE* fin;
logmsg("Parsing '%s' as covariance function",fname);
logtchk("reading covariance function from disk, ndays = %d",ndays);
if (!(fin = fopen(fname,"r")))
{
logerr("Unable to open covariance function file: %s",fname);
exit(1);
}
logdbg("ndays = %d",ndays);
fscanf(fin,"%lf",&escaleFactor);
for (i=0;i<=ndays;i++)
{
if (fscanf(fin,"%lf",&covarFunc[i])!=1)
{
logerr("Incorrect number of days in the Cholesky matrix: %s, trying to read %d days",fname,ndays);
exit(1);
}
}
fclose(fin);
if(escaleFactor!=1.0){
logerr("Ignoring 'error scale factor': %g",escaleFactor);
}
logtchk("complete reading covariance function from disk");
cholesky_covarFunc2matrix(m,covarFunc,ndays,resx,resy,rese,np,nc);
}
HRESULT CDebugInfoWalker::_AddFuncToList(
_In_ CFunctionSizes & funcList,
_In_ IDiaSymbol *pSymbol,
_In_ set<wstring> const & aszFuncNamesToMatch)
{
BSTR symName;
HRESULT hr = pSymbol->get_name(&symName);
if(hr == S_OK)
{
// Is this a function requested by the user?
if(aszFuncNamesToMatch.find(symName) != aszFuncNamesToMatch.end())
{
ULONGLONG ullSize;
if(pSymbol->get_length(&ullSize) == S_OK)
{
funcList.addData(symName, ullSize);
}
}
#ifdef _DEBUG
else
{
logdbg(L"Skipping: %s", symName);
}
#endif
SysFreeString(symName);
}
return hr;
}
IoEvent::~IoEvent() {
#ifdef WINDOWS
if (m_handle != INVALID_HANDLE_VALUE) {
CloseHandle(m_handle);
m_handle = NULL;
}
#else // !WINDOWS
#if IO_EVENT_USE_POLL
if (m_pipe[0] >= 0) {
if (m_ownsFDs)
close(m_pipe[0]);
m_pipe[0] = -1;
}
if (m_pipe[1] >= 0) {
if (m_ownsFDs)
close(m_pipe[1]);
m_pipe[1] = -1;
}
#elif IO_EVENT_USE_KQUEUE
logdbg("%p", this);
deleteEvent();
m_type = IoEventTypeNone;
m_ident = -1;
#endif // IO_EVENT_USE_xxx
#endif // WINDOWS
}
int Session::on_connect()
{
logdbg("session connect:%s, pid:%d\n",
get_string_ip().c_str(), g_pid);
m_start_time = get_cur_time_ms();
m_active_time = m_start_time;
return 0;
}
static void dump_logarea (void)
{
struct logmsg * msg;
logdbg(stderr, "\n==== area: start addr = %p, end addr = %p ====\n",
la->start, la->end);
logdbg(stderr, "|addr |next |prio|msg\n");
for (msg = (struct logmsg *)la->head; (void *)msg != la->tail;
msg = msg->next)
logdbg(stderr, "|%p |%p |%i |%s\n", (void *)msg, msg->next,
msg->prio, (char *)&msg->str);
logdbg(stderr, "|%p |%p |%i |%s\n", (void *)msg, msg->next,
msg->prio, (char *)&msg->str);
logdbg(stderr, "\n\n");
}
void signal_cb(evutil_socket_t sig, short events, void *user_data)
{
struct event_base *base = (struct event_base*)user_data;
struct timeval delay = { 2, 0 };
logdbg("Caught an interrupt signal; exiting cleanly in two seconds.\n");
//cleanup task
SingletonHolder<SessionMgr>::Instance()->Clear();
event_base_loopexit(base, &delay);
}
int SessionMgr::Del( Session *pSession )
{
if (!pSession)
{
logerr("pSession NULL\n");
}
logdbg("session delete[%s:%d]\n",pSession->OnGetIPAddr().c_str(), pSession->OnGetPort());
Del((pSession->GetKey()));
return 0;
}
int Session::on_close()
{
logdbg("session close:%s, pid:%d\n",
get_string_ip().c_str(), g_pid);
reset_buffer();
close(m_sockfd);
m_sockfd = -1;
return 0;
}
int Session::notify_master(struct commu_msg &msg)
{
int n = writen(g_fifo_fd, (u_char *)&msg, sizeof(msg));
if (n != sizeof(msg))
{
logerr("write fifo failed!");
return -1;
}
logdbg("slave notify master\n");
return 0;
}
int NetworkWrapper::Tick()
{
logdbg("Used blocks %d, usag %d%%\n",
SingletonHolder<ShmqWrapper>::Instance()->GetUsedBlocks()
,SingletonHolder<ShmqWrapper>::Instance()->GetUsage());
struct timeval tv;
tv.tv_sec = 1;
tv.tv_usec = 0;
event_add(m_stTimeEvt, &tv);
return 0;
}
int log_init(char *program_name, int size)
{
logdbg(stderr,"enter log_init\n");
log_name = program_name;
if (log_daemon) {
struct sigaction sa_old;
struct sigaction sa_new;
pid_t pid;
openlog(log_name, 0, LOG_DAEMON);
setlogmask (LOG_UPTO (LOG_DEBUG));
if (logarea_init(size)) {
syslog(LOG_ERR, "logarea init failed");
return -1;
}
pid = fork();
if (pid < 0) {
syslog(LOG_ERR, "starting logger failed");
exit(1);
} else if (pid) {
syslog(LOG_WARNING,
"iSCSI logger with pid=%d started!", pid);
return pid;
}
daemon_init();
/* flush on daemon's crash */
sa_new.sa_handler = (void*)catch_signal;
sigemptyset(&sa_new.sa_mask);
sa_new.sa_flags = 0;
sigaction(SIGSEGV, &sa_new, &sa_old );
sigaction(SIGTERM, &sa_new, &sa_old );
while(1) {
log_flush();
sleep(1);
if (log_stop_daemon)
break;
}
__log_close();
exit(0);
}
return 0;
}
void IoEvent::initEvent(int kqueue, struct kevent *kevent) {
m_kqueue = kqueue;
if (kevent) {
logdbg("%p", this);
if (m_type == IoEventTypeFile)
// File descriptor event
EV_SET(kevent, m_ident, EVFILT_READ, EV_ADD | EV_ENABLE, 0, 0, 0);
else if (m_type == IoEventTypeUser)
// User event
EV_SET(kevent, m_ident, EVFILT_USER, EV_ADD | EV_ENABLE, NOTE_TRIGGER, 0, 0);
}
}
int SessionMgr::Clear()
{
logdbg("Clear All Session\n");
SMAP::iterator it;
for (it = m_stSessionMap.begin(); it != m_stSessionMap.end(); ++it)
{
if (it->second)
{
delete it->second;
}
}
m_stSessionMap.clear();
return 0;
}
static ssize_t auth_bypass_attr_show(struct module_attribute *mattr,
struct module *mod, char *buf)
{
mutex_lock(&s_auth_cfg.auth_cfg_mutex);
auth_cfg_lock(&s_auth_cfg);
*(int *)buf = auth_cfg_bypass(&s_auth_cfg);
auth_cfg_unlock(&s_auth_cfg);
mutex_unlock(&s_auth_cfg.auth_cfg_mutex);
buf[4] = 0;
logdbg("bypass : %d\n", *(int *)buf);
return 4;
}
void initialise(pulsar *psr,int noWarnings)
{
int p;
const char *CVS_verNum = "$Id: 56cb3396b0d85a3876be0530d60f6aadde41d468 $";
if (displayCVSversion == 1) CVSdisplayVersion("initialise.C","initialise()",CVS_verNum);
// allocate space for covar arrays
int fullSetup = 1;
logdbg("Initialise");
for (p=0;p<MAX_PSR;p++)
// if (psr[p].obsn == NULL)
initialiseOne (psr+p, noWarnings, fullSetup);
}
void _check_prereqs_xplatform()
{
CommandLine cl("docker", { "version","--format","{{.Server.Version}}" });
std::string op;
if (utils::runcommand(cl, op) != 0)
fatal("Running \"docker --version\" failed!\nIs docker correctly installed on this machine?\n" + op);
std::string major, minor;
unsigned int i;
for (i = 0; i < op.length() && op[i] != '.'; ++i)
major += op[i];
for (++i; i < op.length() && op[i] != '.'; ++i)
minor += op[i];
logdbg("Docker major version = " + major + " and minor = " + minor);
if (std::strtol(major.c_str(), 0, 10) == 1 && std::stoi(minor.c_str(), 0, 10) < 12)
fatal("dRunner requires docker version 1.12 or newer. Please update!");
}
void _copyexe()
{
Poco::Path currentexe = drunnerPaths::getPath_Exe();
try
{
if (currentexe.parent().toString().compare(drunnerPaths::getPath_Bin().toString()) != 0)
Poco::File(currentexe).copyTo(drunnerPaths::getPath_Bin().toString());
logdbg("Copied drunner to " + drunnerPaths::getPath_Bin().toString());
drunner_assert(utils::fileexists(drunnerPaths::getPath_Exe_Target()), "Failed to install drunner.exe");
}
catch (const Poco::FileException & e)
{
logmsg(kLWARN, std::string("Couldn't copy exe to bin directory: ") + e.what());
}
}
void t2Fit_fillGlobalFitInfo(pulsar* psr, unsigned int npsr,FitInfo &OUT){
OUT.nParams=0;
OUT.nConstraints=0;
for (int i=1;i<=psr->nJumps;i++) {
if (psr->fitJump[i]==2)
{
logdbg("Global Jump");
OUT.paramIndex[OUT.nParams]=param_JUMP;
OUT.paramCounters[OUT.nParams]=i;
OUT.paramDerivs[OUT.nParams] =t2FitFunc_jump;
OUT.updateFunctions[OUT.nParams] =t2UpdateFunc_jump;
++OUT.nParams;
}
}
// Use pulsar zero to define the global parameters.
t2Fit_fillFitInfo_INNER(psr,OUT,2);
}
int log_init(char *program_name, int size, int daemon, int debug)
{
is_daemon = daemon;
is_debug = debug;
logdbg(stderr,"enter log_init\n");
log_name = program_name;
if (is_daemon) {
struct sigaction sa_old;
struct sigaction sa_new;
pid_t pid;
openlog(log_name, 0, LOG_DAEMON);
setlogmask (LOG_UPTO (LOG_DEBUG));
if (logarea_init(size))
return 1;
pid = fork();
if (pid < 0) {
syslog(LOG_ERR, "starting logger failed\n");
exit(1);
} else if (pid) {
syslog(LOG_WARNING,
"Target daemon logger with pid=%d started!\n", pid);
return 0;
}
/* flush on daemon's crash */
sa_new.sa_handler = (void*)log_flush;
sigemptyset(&sa_new.sa_mask);
sa_new.sa_flags = 0;
sigaction(SIGSEGV, &sa_new, &sa_old );
while(1) {
log_flush();
sleep(1);
}
exit(0);
}
return 0;
}
int verify_buff_fill(struct verify_buff_st *mb, char *buff, int len, int idx, del_callback cb, void *param) {
int total = 0, i, maxid;
struct ap_user *user;
char *pos, *end;
if (!mb->count)
return 0;
pos = buff, end = buff + len;
for (i = 0; i < mb->count; i++) {
int left = end - pos;
if (left < AP_USER_SIZE + sizeof(idx)) {
logerr("buff too small %d %d\n", left, AP_USER_SIZE + sizeof(idx));
break;
}
user = (struct ap_user*)mb->data[i];
if (user->status == 'v') {
memcpy(pos, &idx, sizeof(idx)); pos += sizeof(idx);
ap_user_fill(user, pos, AP_USER_SIZE); pos += AP_USER_SIZE;
total += AP_USER_SIZE + sizeof(idx);
cb(user, param);
continue;
}
/* 微信登录时，会直接把待认证的user节点从'v'改成'w' */
{
unsigned char *mac = user->mac;
logdbg("status %c %d %02x-%02x-%02x-%02x-%02x-%02x\n", user->status, idx, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
}
}
maxid = 0;
if (i < mb->count) {
maxid = mb->count - i;
logerr("buffer too small len %d, need %d %d %d\n", len, (AP_IP_SIZE + AP_MAC_SIZE) * mb->count, i, mb->count);
memmove(&mb->data[0], &mb->data[i], maxid * sizeof(void *));
}
mb->count = maxid;
return total;
}
