/* * Get memory */ LOCAL void* imalloc( size_t size, IMACB *imacb ) { QUEUE *q; VP mem; UW imask; /* If it is smaller than the minimum fragment size, allocate the minimum size to it. */ if ( size < MIN_FRAGMENT ) { size = MIN_FRAGMENT; } size = ROUND(size); DI(imask); /* Exclusive control by interrupt disable */ SpinLock(&MemLockObj); /* Search FreeQue */ q = searchFreeArea(size, imacb); if ( q != &imacb->freeque ) { /* There is free area: Split from FreeQue once */ removeFreeQue(q); q = q - 1; } else { /* Reserve new pages because there is no free space */ QUEUE *e; size_t n; /* Reserve pages */ SpinUnlock(&MemLockObj); EI(imask); n = PageCount(size + sizeof(QUEUE) * 2); q = GetSysMemBlk(n, imacb->mematr); if ( q == NULL ) { goto err_ret; /* Insufficient memory */ } DI(imask); SpinLock(&MemLockObj); /* Register on AreaQue */ e = (QUEUE*)((VB*)q + n * pagesz) - 1; insertAreaQue(&imacb->areaque, e); insertAreaQue(&imacb->areaque, q); setAreaFlag(q, AREA_TOP); setAreaFlag(e, AREA_END); } /* Allocate memory */ mem = mem_alloc(q, size, imacb); SpinUnlock(&MemLockObj); EI(imask); return mem; err_ret: BMS_DEBUG_PRINT(("imalloc error\n")); return NULL; }
// Flushes all available packets over the network... returns number of bytes sent bool AsyncStream::Flush(Socket &s) { OVR_CAPTURE_CPU_ZONE(AsyncStream_Flush); bool okay = true; // Take ownership of any pending data... SpinLock(m_bufferLock); Swap(m_cacheBegin, m_flushBegin); Swap(m_cacheTail, m_flushTail); Swap(m_cacheEnd, m_flushEnd); SpinUnlock(m_bufferLock); // Signal that we just swapped in a new buffer... wake up any threads that were waiting on us to flush. m_gate.Open(); if(m_flushTail > m_flushBegin) { const size_t sendSize = (size_t)(m_flushTail-m_flushBegin); // first send stream header... StreamHeaderPacket streamheader; streamheader.threadID = m_threadID; streamheader.streamSize = sendSize; okay = s.Send(&streamheader, sizeof(streamheader)); // This send payload... okay = okay && s.Send(m_flushBegin, sendSize); m_flushTail = m_flushBegin; } OVR_CAPTURE_ASSERT(m_flushBegin == m_flushTail); // should be empty at this point... return okay; }
/*! Allocate PID info structure \param ppid - parent process id \return on success - pid info structure on failure - null */ PID_INFO_PTR AllocatePidInfo(int ppid) { PID_INFO_PTR pid_info, pid_free; pid_info = AllocateBuffer(&pid_cache, CACHE_ALLOC_SLEEP); if ( pid_info == NULL ) return NULL; SpinLock( &pid_info_lock ); pid_free = STRUCT_ADDRESS_FROM_MEMBER( pid_zero.free_list.next, PID_INFO, free_list ); assert( pid_free != NULL ); assert( pid_free->free_count > 0 ); pid_free->free_count--; /*use the first available pid*/ pid_info->pid = pid_free->pid + 1; pid_info->ppid = ppid; pid_info->free_count = pid_free->free_count; if ( pid_free->free_count > 0 ) AddToList( &pid_free->free_list, &pid_info->free_list ); RemoveFromList( &pid_free->free_list ); /*add to the used pid list*/ AddToList( &pid_free->inuse_list, &pid_info->inuse_list ); /*add to the tree*/ InsertNodeIntoAvlTree( &pid_root, &pid_info->tree_node, 0, compare_pid_info ); SpinUnlock( &pid_info_lock ); return pid_info; }
bool Label::ConditionalInit(const char *name) { SpinLock(g_labelLock); if(!m_name) Init(name); SpinUnlock(g_labelLock); return true; }
void FreePidInfo(PID_INFO_PTR pid_info) { PID_INFO_PTR prev_used_pid, prev_free_pid; assert( pid_info != NULL ); assert( pid_info != &pid_zero ); SpinLock( &pid_info_lock ); prev_used_pid = STRUCT_ADDRESS_FROM_MEMBER( &pid_info->inuse_list.prev, PID_INFO, inuse_list.prev ); prev_free_pid = STRUCT_ADDRESS_FROM_MEMBER( &pid_info->free_list.prev, PID_INFO, free_list.prev ); /*transfer free pids to previous node*/ prev_used_pid->free_count = pid_info->free_count + 1; if ( pid_info->free_count > 0 ) { AddToList( &prev_used_pid->free_list, &pid_info->free_list ); RemoveFromList( &pid_info->free_list ); } else AddToList( &prev_used_pid->free_list, &pid_zero.free_list ); RemoveFromList( &pid_info->inuse_list ); RemoveNodeFromAvlTree( &pid_root, &pid_info->tree_node, 0, compare_pid_info); SpinUnlock( &pid_info_lock ); FreeBuffer( pid_info, &pid_cache ); }
/* * Free memory * It may be called during interrupt disable. In this case, need to wait * until interrupt is enabled and until free. */ LOCAL void ifree( void *ptr, IMACB *imacb ) { QUEUE *aq; UW imask; DI(imask); /* Exclusive control by interrupt disable */ SpinLock(&MemLockObj); aq = (QUEUE*)ptr - 1; clrAreaFlag(aq, AREA_USE); if ( !chkAreaFlag(aq->next, AREA_END|AREA_USE) ) { /* Merge with free area in after location */ removeFreeQue(aq->next + 1); removeAreaQue(aq->next); } if ( !chkAreaFlag(aq, AREA_TOP) && !chkAreaFlag(aq->prev, AREA_USE) ) { /* Merge with free area in front location */ aq = aq->prev; removeFreeQue(aq + 1); removeAreaQue(aq->next); } /* If the whole page is free, then free the page. * However, do not free the page if it is called during * interrupt disabled. */ if ( !isDI(imask) && chkAreaFlag(aq, AREA_TOP) && chkAreaFlag(aq->next, AREA_END) ) { /* Free pages */ removeAreaQue(aq->next); removeAreaQue(aq); SpinUnlock(&MemLockObj); EI(imask); RelSysMemBlk(aq); DI(imask); SpinLock(&MemLockObj); } else { /* Register free area to FreeQue */ appendFreeArea(aq, imacb); } SpinUnlock(&MemLockObj); EI(imask); }
/*! Creates and initalizes a vm descriptor \param vmap - virtual map of this descriptor \param start - starting va address of this descriptor range \param end - ending va address of this descriptor range \param vm_unit - vm unit which is backing this descriptor \param protection - protection for this range \return on success pointer to vm descriptor on failure null */ VM_DESCRIPTOR_PTR CreateVmDescriptor(VIRTUAL_MAP_PTR vmap, VADDR start, VADDR end, VM_UNIT_PTR vm_unit, VM_PROTECTION_PTR protection) { VM_DESCRIPTOR_PTR vd; assert( PAGE_ALIGN_UP(end-start) <= PAGE_ALIGN_UP(vm_unit->size) ); SpinLock(&vmap->lock); vmap->reference_count++; SpinUnlock(&vmap->lock); start = PAGE_ALIGN(start); //end = PAGE_ALIGN_UP(end)-1; vd = (VM_DESCRIPTOR_PTR)kmalloc(sizeof(VM_DESCRIPTOR), KMEM_NO_FAIL); //vd = AllocateBuffer( &vm_descriptor_cache, 0 ); InitVmDescriptor( vd, vmap, start, end, vm_unit, protection); SpinLock(&vm_unit->lock); vm_unit->reference_count++; SpinUnlock(&vm_unit->lock); vd->reference_count++; return vd; }
CLzoWorkBuffer::~CLzoWorkBuffer() { SpinLock( &m_hLock ); while( !m_stkBuffer.empty() ) { delete[] reinterpret_cast<lzo_align_t*>( m_stkBuffer.top() ); m_stkBuffer.pop(); } SpinUnlock( &m_hLock ); TLS_DestroyKey( m_tlsKey ); DestroySpinLock( &m_hLock ); }
void * mythread(void *arg) { char *letter = arg; printf("%s: begin\n", letter); int i; for (i = 0; i < max; i++) { SpinLock(&mutex); balance = balance + 1; SpinUnlock(&mutex); } printf("%s: done\n", letter); return NULL; }
bool CTrThreadMsgBuffer::HandleAllLeftMsg() { SpinLock(&m_Lock); std::swap(m_pWaitingLeftControlMsg, m_pDoingLeftControlMsg); SpinUnlock(&m_Lock); const size_t stSize = m_pDoingLeftControlMsg->size(); for(size_t i = 0; i < stSize; i++) { ETrBallMsg eMsg = m_pDoingLeftControlMsg->at(i); HandleLeftControlMsg(eMsg); } m_pDoingLeftControlMsg->clear(); return m_bQuit; }
void CTrMsgBufferSwapper::HandleAllRightMsg() { SpinLock(&m_Lock); std::swap(m_pWaitingRightControlMsg, m_pDoingRightControlMsg); SpinUnlock(&m_Lock); size_t stSize = m_pDoingRightControlMsg->size(); for(size_t i = 0; i < stSize; i++) { IndexMsgPair_t& Value = m_pDoingRightControlMsg->at(i); CTrThreadMsgBuffer* pBuffer = m_vecTrBuffer[Value.first]; pBuffer->HandleRightControlMsg((ETrBallMsg)Value.second); } m_pDoingRightControlMsg->clear(); }
char* CLzoWorkBuffer::GetBuffer() { char* pMem=reinterpret_cast<char*>( TLS_GetValue( m_tlsKey ) ); if( !pMem ) { //为什么要new这么多内存,参考testmini.c中的例子,这个文件是minilzo附带的. pMem=reinterpret_cast<char*> (new lzo_align_t[((LZO1X_1_MEM_COMPRESS) + (sizeof(lzo_align_t) - 1)) / sizeof(lzo_align_t)]); SpinLock( &m_hLock ); m_stkBuffer.push( pMem ); SpinUnlock( &m_hLock ); TLS_SetValue( m_tlsKey, pMem ); } return pMem; }
pulsesequence() { double slpwrT = getval("slpwrT"), slpwT = getval("slpwT"), mixT = getval("mixT"), trim = getval("trim"), tauz1 = getval("tauz1"), tauz2 = getval("tauz2"), tauz3 = getval("tauz3"), tauz4 = getval("tauz4"), selpwrA = getval("selpwrA"), selpwA = getval("selpwA"), gzlvlA = getval("gzlvlA"), gtA = getval("gtA"), selpwrB = getval("selpwrB"), selpwB = getval("selpwB"), gzlvlB = getval("gzlvlB"), gtB = getval("gtB"), gstab = getval("gstab"), selfrq = getval("selfrq"); char selshapeA[MAXSTR], selshapeB[MAXSTR], slpatT[MAXSTR]; //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gtA = syncGradTime("gtA","gzlvlA",1.0); gzlvlA = syncGradLvl("gtA","gzlvlA",1.0); gtB = syncGradTime("gtB","gzlvlB",1.0); gzlvlB = syncGradLvl("gtB","gzlvlB",1.0); getstr("slpatT",slpatT); getstr("selshapeA",selshapeA); getstr("selshapeB",selshapeB); if (strcmp(slpatT,"mlev17c") && strcmp(slpatT,"dipsi2") && strcmp(slpatT,"dipsi3") && strcmp(slpatT,"mlev17") && strcmp(slpatT,"mlev16")) abort_message("SpinLock pattern %s not supported!.\n", slpatT); assign(ct,v6); if (getflag("zqfilt")) { hlv(v6,v6); hlv(v6,v6); } settable(t1,4,ph1); getelem(t1,v6,v1); settable(t3,8,ph3); getelem(t3,v6,v11); settable(t4,8,ph4); settable(t2,4,ph2); getelem(t2,v6,v2); settable(t7,8,ph7); getelem(t7,v6,v7); settable(t8,4,ph8); getelem(t8,v6,v8); if (getflag("zqfilt")) getelem(t4,v6,oph); else assign(v1,oph); sub(v2,one,v3); add(v2,two,v4); add(v3,two,v5); mod4(ct,v10); /* BEGIN THE ACTUAL PULSE SEQUENCE */ status(A); obspower(tpwr); delay(5.0e-5); if (getflag("sspul")) steadystate(); if (satmode[0] == 'y') { if ((d1-satdly) > 0.02) delay(d1-satdly); else delay(0.02); satpulse(satdly,v6,rof1,rof1); } else delay(d1); if (getflag("wet")) wet4(zero,one); status(B); rgpulse(pw, v1, rof1, rof1); if (selfrq != tof) obsoffset(selfrq); zgradpulse(gzlvlA,gtA); delay(gstab); obspower(selpwrA); shaped_pulse(selshapeA,selpwA,v1,rof1,rof1); obspower(tpwr); zgradpulse(gzlvlA,gtA); delay(gstab); if (selfrq != tof) delay(2*OFFSET_DELAY); zgradpulse(gzlvlB,gtB); delay(gstab); obspower(selpwrB); shaped_pulse(selshapeB,selpwB,v2,rof1,rof1); obspower(slpwrT); zgradpulse(gzlvlB,gtB); delay(gstab); if (selfrq != tof) obsoffset(tof); if (mixT > 0.0) { rgpulse(trim,v11,0.0,0.0); if (dps_flag) rgpulse(mixT,v3,0.0,0.0); else SpinLock(slpatT,mixT,slpwT,v2,v3,v4,v5, v9); } if (getflag("zqfilt")) { obspower(tpwr); rgpulse(pw,v7,1.0e-6,rof1); ifzero(v10); delay(tauz1); endif(v10); decr(v10); ifzero(v10); delay(tauz2); endif(v10); decr(v10); ifzero(v10); delay(tauz3); endif(v10); decr(v10); ifzero(v10); delay(tauz4); endif(v10); rgpulse(pw,v8,rof1,rof2); } else delay(rof2); status(C); }
pulsesequence() { double slpwrT = getval("slpwrT"), slpwT = getval("slpwT"), mixT = getval("mixT"), gzlvl1 = getval("gzlvl1"), gt1 = getval("gt1"), gzlvl2 = getval("gzlvl2"), gt2 = getval("gt2"), gstab = getval("gstab"), selpwrA = getval("selpwrA"), selpwA = getval("selpwA"), gzlvlA = getval("gzlvlA"), gtA = getval("gtA"), selpwrB = getval("selpwrB"), selpwB = getval("selpwB"), gzlvlB = getval("gzlvlB"), gtB = getval("gtB"), selfrq = getval("selfrq"), zqfpw1 = getval("zqfpw1"), zqfpwr1 = getval("zqfpwr1"), zqfpw2 = getval("zqfpw2"), zqfpwr2 = getval("zqfpwr2"), gzlvlzq1 = getval("gzlvlzq1"), gzlvlzq2 = getval("gzlvlzq2"); char slpatT[MAXSTR], selshapeA[MAXSTR], selshapeB[MAXSTR], zqfpat1[MAXSTR], zqfpat2[MAXSTR]; //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gtA = syncGradTime("gtA","gzlvlA",1.0); gzlvlA = syncGradLvl("gtA","gzlvlA",1.0); gtB = syncGradTime("gtB","gzlvlB",1.0); gzlvlB = syncGradLvl("gtB","gzlvlB",1.0); getstr("slpatT",slpatT); getstr("selshapeA",selshapeA); getstr("selshapeB",selshapeB); getstr("zqfpat1",zqfpat1); getstr("zqfpat2",zqfpat2); if (strcmp(slpatT,"mlev17c") && strcmp(slpatT,"dipsi2") && strcmp(slpatT,"dipsi3") && strcmp(slpatT,"mlev17") && strcmp(slpatT,"mlev16")) abort_message("SpinLock pattern %s not supported!.\n", slpatT); /* STEADY-STATE PHASECYCLING */ /* This section determines if the phase calculations trigger off of (SS - SSCTR) or off of CT */ ifzero(ssctr); assign(ct,v13); elsenz(ssctr); sub(ssval, ssctr, v13); /* v13 = 0,...,ss-1 */ endif(ssctr); mod4(v13,v1); /* v1 = 0 1 2 3 */ hlv(v13,v13); hlv(v13,v13); mod4(v13,v11); /* v11 = 0000 1111 2222 3333 */ dbl(v1,oph); add(v11,oph,oph); add(v11,oph,oph); /* oph = 2v1 + 2v11 */ /* CYCLOPS */ hlv(v13,v13); hlv(v13,v14); add(v1,v14,v1); add(v11,v14,v11); add(oph,v14,oph); assign(v14,v3); add(one,v3,v3); add(two,v3,v12); sub(v3,one,v2); add(v3,one,v4); add(v3,two,v5); /* BEGIN THE ACTUAL PULSE SEQUENCE */ status(A); obspower(tpwr); delay(5.0e-5); if (getflag("sspul")) steadystate(); if (satmode[0] == 'y') { if ((d1-satdly) > 0.02) delay(d1-satdly); else delay(0.02); satpulse(satdly,v6,rof1,rof1); } else delay(d1); if (getflag("wet")) wet4(zero,one); status(B); rgpulse(pw, v14, rof1, rof1); if (selfrq != tof) obsoffset(selfrq); zgradpulse(gzlvlA,gtA); delay(gstab); obspower(selpwrA); shaped_pulse(selshapeA,selpwA,v1,rof1,rof1); obspower(tpwr); zgradpulse(gzlvlA,gtA); delay(gstab); if (selfrq != tof) delay(2*OFFSET_DELAY); zgradpulse(gzlvlB,gtB); delay(gstab); obspower(selpwrB); shaped_pulse(selshapeB,selpwB,v11,rof1,rof1); obspower(tpwr); zgradpulse(gzlvlB,gtB); delay(gstab); if (selfrq != tof) obsoffset(tof); rgpulse(pw, v14, rof1, rof1); if (getflag("Gzqfilt")) { obspower(zqfpwr1); rgradient('z',gzlvlzq1); delay(100.0e-6); shaped_pulse(zqfpat1,zqfpw1,v14,rof1,rof1); delay(100.0e-6); rgradient('z',0.0); delay(gstab); } obspower(slpwrT); zgradpulse(gzlvl1,gt1); delay(gstab); if (mixT > 0.0) { if (dps_flag) rgpulse(mixT,v3,0.0,0.0); else SpinLock(slpatT,mixT,slpwT,v2,v3,v4,v5, v9); } if (getflag("Gzqfilt")) { obspower(zqfpwr2); rgradient('z',gzlvlzq2); delay(100.0e-6); shaped_pulse(zqfpat2,zqfpw2,v14,rof1,rof1); delay(100.0e-6); rgradient('z',0.0); delay(gstab); } obspower(tpwr); zgradpulse(gzlvl2,gt2); delay(gstab); rgpulse(pw,v14,rof1,rof2); status(C); }
pulsesequence() { double selpwrA = getval("selpwrA"), selpwA = getval("selpwA"), gzlvlA = getval("gzlvlA"), gtA = getval("gtA"), selpwrB = getval("selpwrB"), selpwB = getval("selpwB"), gzlvlB = getval("gzlvlB"), gtB = getval("gtB"), gstab = getval("gstab"), slpwrT = getval("slpwrT"), slpwT = getval("slpwT"), mixT = getval("mixT"), gzlvl1 = getval("gzlvl1"), gt1 = getval("gt1"), gzlvl2 = getval("gzlvl2"), gt2 = getval("gt2"), alfa1, t1dly, zqfpw1 = getval("zqfpw1"), zqfpwr1 = getval("zqfpwr1"), zqfpw2 = getval("zqfpw2"), zqfpwr2 = getval("zqfpwr2"), gzlvlzq1 = getval("gzlvlzq1"), gzlvlzq2 = getval("gzlvlzq2"); char slpatT[MAXSTR], selshapeA[MAXSTR], selshapeB[MAXSTR], zqfpat1[MAXSTR], zqfpat2[MAXSTR]; int phase1 = (int)(getval("phase")+0.5), prgcycle = (int)(getval("prgcycle")+0.5); //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gtA = syncGradTime("gtA","gzlvlA",1.0); gzlvlA = syncGradLvl("gtA","gzlvlA",1.0); gtB = syncGradTime("gtB","gzlvlB",1.0); gzlvlB = syncGradLvl("gtB","gzlvlB",1.0); /* LOAD AND INITIALIZE VARIABLES */ getstr("selshapeA",selshapeA); getstr("selshapeB",selshapeB); getstr("slpatT",slpatT); getstr("zqfpat1",zqfpat1); getstr("zqfpat2",zqfpat2); alfa1 = (4*pw/PI) + 4.0e-6; if (getflag("homodec")) alfa1 = alfa1 + 2.0e-6 + 2*pw; t1dly = d2-alfa1; if (t1dly > 0.0) t1dly = t1dly; else t1dly = 0.0; if (strcmp(slpatT,"mlev17c") && strcmp(slpatT,"dipsi2") && strcmp(slpatT,"dipsi3") && strcmp(slpatT,"mlev17") && strcmp(slpatT,"mlev16")) abort_message("SpinLock pattern %s not supported!.\n", slpatT); assign(ct,v17); assign(zero,v18); assign(zero,v19); if (getflag("prgflg") && (satmode[0] == 'y') && (prgcycle > 1.5)) { hlv(ct,v17); mod2(ct,v18); dbl(v18,v18); if (prgcycle > 2.5) { hlv(v17,v17); hlv(ct,v19); mod2(v19,v19); dbl(v19,v19); } } /* mod2(id2,v14); dbl(v14,v14); */ initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14); settable(t1,4,ph1); getelem(t1,v17,v6); settable(t2,4,ph2); getelem(t2,v17,v1); settable(t3,8,ph3); getelem(t3,v17,oph); settable(t5,4,ph5); getelem(t5,v17,v21); settable(t7,8,ph7); getelem(t7,v17,v7); settable(t8,4,ph8); getelem(t8,v17,v8); if (getflag("prgflg") && (satmode[0] == 'y')) sub(v6,one,v6); add(oph,v18,oph); add(oph,v19,oph); assign(v1,v11); add(v11,two,v12); assign(oph,v13); if (phase1 == 2) {incr(v1); incr(v6);} add(v1, v14, v1); add(v6, v14, v6); add(oph,v14,oph); if (getflag("homodec")) add(oph,two,oph); /* BEGIN ACTUAL PULSE SEQUENCE CODE */ status(A); obspower(tpwr); delay(5.0e-5); if (getflag("sspul")) steadystate(); if (satmode[0] == 'y') { if ((d1-satdly) > 0.02) delay(d1-satdly); else delay(0.02); if (getflag("slpsat")) { shaped_satpulse("relaxD",satdly,v6); if (getflag("prgflg")) shaped_purge(v1,v6,v18,v19); } else { satpulse(satdly,v6,rof1,rof1); if (getflag("prgflg")) purge(v1,v6,v18,v19); } } else delay(d1); if (getflag("wet")) wet4(zero,one); status(B); rgpulse(pw, v1, rof1, 2.0e-6); if (getflag("homodec")) { delay(t1dly/2); rgpulse(2*pw,v13,1.0e-6,1.0e-6); } else delay(t1dly); zgradpulse(gzlvlA,gtA); delay(gstab); obspower(selpwrA); shaped_pulse(selshapeA,selpwA,v11,rof1,rof1); obspower(tpwr); zgradpulse(gzlvlA,gtA); delay(gstab); if (getflag("homodec")) delay(t1dly/2); zgradpulse(gzlvlB,gtB); delay(gstab); obspower(selpwrB); shaped_pulse(selshapeB,selpwB,v12,rof1,rof1); obspower(tpwr); zgradpulse(gzlvlB,gtB); delay(gstab); rgpulse(pw,v7,2.0e-6,rof1); if (mixT > 0.0) { if (getflag("Gzqfilt")) { obspower(zqfpwr1); rgradient('z',gzlvlzq1); delay(100.0e-6); shaped_pulse(zqfpat1,zqfpw1,zero,rof1,rof1); delay(100.0e-6); rgradient('z',0.0); delay(100e-6); } obspower(slpwrT); zgradpulse(gzlvl1,gt1); delay(gt1); if (dps_flag) rgpulse(mixT,v21,0.0,0.0); else SpinLock(slpatT,mixT,slpwT,v21); if (getflag("Gzqfilt")) { obspower(zqfpwr2); rgradient('z',gzlvlzq2); delay(100.0e-6); shaped_pulse(zqfpat2,zqfpw2,zero,rof1,rof1); delay(100.0e-6); rgradient('z',0.0); delay(100e-6); } obspower(tpwr); zgradpulse(gzlvl2,gt2); delay(gt2); } rgpulse(pw,v8,rof1,rof2); status(C); }
pulsesequence() { double gzlvlE = getval("gzlvlE"), gtE = getval("gtE"), EDratio = getval("EDratio"), gstab = getval("gstab"), pwx180 = getval("pwx180"), pwxlvl180 = getval("pwxlvl180"), hsglvl = getval("hsglvl"), hsgt = getval("hsgt"), slpwT = getval("slpwT"), slpwrT = getval("slpwrT"), trim = getval("trim"), mixT = getval("mixT"), tau = 1/(4*(getval("j1xh"))), evolcorr, taug; int icosel, prgcycle = (int)(getval("prgcycle")+0.5), phase1 = (int)(getval("phase")+0.5); char pwx180ad[MAXSTR], pwx180adR[MAXSTR], slpatT[MAXSTR]; //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gtE = syncGradTime("gtE","gzlvlE",0.5); gzlvlE = syncGradLvl("gtE","gzlvlE",0.5); getstr("pwx180ad", pwx180ad); getstr("pwx180adR", pwx180adR); getstr("slpatT",slpatT); evolcorr=(4*pwx/PI)+2*pw+8.0e-6; if (strcmp(slpatT,"mlev17c") && strcmp(slpatT,"dipsi2") && strcmp(slpatT,"dipsi3") && strcmp(slpatT,"mlev17") && strcmp(slpatT,"mlev16")) abort_message("SpinLock pattern %s not supported!.\n", slpatT); taug = gtE + gstab + 2 * GRADIENT_DELAY; icosel = 1; assign(ct,v17); assign(zero,v18); assign(zero,v19); if (getflag("prgflg") && (satmode[0] == 'y') && (prgcycle > 1.5)) { hlv(ct,v17); mod2(ct,v18); dbl(v18,v18); if (prgcycle > 2.5) { hlv(v17,v17); hlv(ct,v19); mod2(v19,v19); dbl(v19,v19); } } settable(t1, 4, ph1); settable(t2, 2, ph2); settable(t3, 8, ph3); settable(t4, 16, ph4); settable(t5, 16, ph5); getelem(t1, v17, v1); getelem(t3, v17, v3); getelem(t4, v17, v4); getelem(t2, v17, v2); getelem(t5, v17, oph); assign(zero,v6); add(oph,v18,oph); add(oph,v19,oph); assign(two,v21); if ((phase1 == 2) || (phase1 == 5)) icosel = -1; /* mod2(id2,v14); dbl(v14, v14); */ initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14); add(v2, v14, v2); add(oph, v14, oph); status(A); obspower(tpwr); delay(5.0e-5); if (getflag("sspul")) steadystate(); if (satmode[0] == 'y') { if ((d1-satdly) > 0.02) delay(d1-satdly); else delay(0.02); if (getflag("slpsat")) { shaped_satpulse("relaxD",satdly,zero); if (getflag("prgflg")) shaped_purge(v6,zero,v18,v19); } else { satpulse(satdly,zero,rof1,rof1); if (getflag("prgflg")) purge(v6,zero,v18,v19); } } else delay(d1); if (getflag("wet")) wet4(zero,one); decpower(pwxlvl); status(B); if (getflag("nullflg")) { rgpulse(0.5 * pw, zero, rof1, rof1); delay(2 * tau); decpower(pwxlvl180); decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1); rgpulse(2.0 * pw, zero, rof1, rof1); delay(2 * tau + 2 * POWER_DELAY); decshaped_pulse(pwx180adR, pwx180, zero, rof1, rof1); decpower(pwxlvl); rgpulse(1.5 * pw, two, rof1, rof1); zgradpulse(hsglvl, hsgt); delay(1e-3); } rgpulse(pw, v6, rof1, rof1); delay(tau); decpower(pwxlvl180); decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1); rgpulse(2.0 * pw, zero, rof1, rof1); delay(tau + 2 * POWER_DELAY); decshaped_pulse(pwx180adR, pwx180, zero, rof1, rof1); decpower(pwxlvl); rgpulse(pw, v1, rof1, rof1); zgradpulse(hsglvl, 2 * hsgt); delay(1e-3); decrgpulse(pwx, v2, rof1, 2.0e-6); delay(d2 / 2); rgpulse(2 * pw, zero, 2.0e-6, 2.0e-6); delay(d2 / 2); delay(taug - POWER_DELAY); decpower(pwxlvl180); decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1); delay(taug + POWER_DELAY - gtE - gstab - 2 * GRADIENT_DELAY+evolcorr); zgradpulse(gzlvlE, gtE); delay(gstab); decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1); decpower(pwxlvl); decrgpulse(pwx, v4, 2.0e-6, rof1); zgradpulse(-0.6 * hsglvl, 1.2 * hsgt); delay(1e-3); rgpulse(pw, v3, rof1, rof1); decpower(pwxlvl180); decshaped_pulse(pwx180adR, pwx180, zero, rof1, rof1); decpower(dpwr); delay(tau - (2 * pw / PI) - rof1); rgpulse(2 * pw, zero, rof1, rof1); decpower(pwxlvl180); decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1); delay(tau); obspower(slpwrT); if (mixT > 0.0) { rgpulse(trim,zero,0.0,0.0); if (dps_flag) rgpulse(mixT,v21,0.0,0.0); else SpinLock(slpatT,mixT,slpwT,v21); } obspower(tpwr); delay(gtE/2 + gstab + 2*GRADIENT_DELAY-rof1); rgpulse(2*pw,zero,rof1,rof2); decpower(dpwr); zgradpulse(icosel*2.0*gzlvlE/EDratio,gtE/2.0); delay(gstab); status(C); }
void pulsesequence() { double gt1 = getval("gt1"), gzlvl1=getval("gzlvl1"), gt2 = getval("gt2"), gzlvl2=getval("gzlvl2"), gt3 = getval("gt3"), gzlvl3=getval("gzlvl3"), gt4 = getval("gt4"), gzlvl4=getval("gzlvl4"), selpwrPS = getval("selpwrPS"), selpwPS = getval("selpwPS"), gzlvlPS = getval("gzlvlPS"), slpwrT = getval("slpwrT"), slpwT = getval("slpwT"), mixT = getval("mixT"), zqfpw1 = getval("zqfpw1"), zqfpwr1 = getval("zqfpwr1"), zqfpw2 = getval("zqfpw2"), zqfpwr2 = getval("zqfpwr2"), gzlvlzq1 = getval("gzlvlzq1"), gzlvlzq2 = getval("gzlvlzq2"), gstab = getval("gstab"); int prgcycle=(int)(getval("prgcycle")+0.5), phase1 = (int)(getval("phase")+0.5); char selshapePS[MAXSTR], slpatT[MAXSTR], zqfpat1[MAXSTR], zqfpat2[MAXSTR]; /* LOAD AND INITIALIZE VARIABLES */ getstr("slpatT",slpatT); getstr("zqfpat1",zqfpat1); getstr("zqfpat2",zqfpat2); if (strcmp(slpatT,"mlev17c") && strcmp(slpatT,"dipsi2") && strcmp(slpatT,"dipsi3") && strcmp(slpatT,"mlev17") && strcmp(slpatT,"mlev16")) abort_message("SpinLock pattern %s not supported!.\n", slpatT); //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gt1 = syncGradTime("gt1","gzlvl1",1.0); gzlvl1 = syncGradLvl("gt1","gzlvl1",1.0); gt2 = syncGradTime("gt2","gzlvl2",1.0); gzlvl2 = syncGradLvl("gt2","gzlvl2",1.0); getstr("selshapePS",selshapePS); assign(ct,v17); initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14); settable(t1,2,ph1); settable(t2,1,ph2); settable(t3,8,ph3); settable(t4,1,ph4); settable(t5,1,ph5); settable(t6,1,ph6); settable(t7,1,ph7); settable(t8,1,ph8); settable(t9,8,ph9); getelem(t1,v17,v1); getelem(t2,v17,v2); getelem(t3,v17,v3); getelem(t4,v17,v4); getelem(t5,v17,v5); getelem(t6,v17,v6); getelem(t7,v17,v7); getelem(t8,v17,v8); getelem(t9,v17,v9); assign(v9,oph); if (phase1 == 2) {incr(v1); } add(v1, v14, v1); add(oph,v14,oph); /* BEGIN THE ACTUAL PULSE SEQUENCE */ status(A); obspower(tpwr); delay(5.0e-5); if (getflag("sspul")) steadystate(); delay(d1); status(B); obspower(tpwr); rgpulse(pw, v1, rof1, rof1); delay(d2/2.0); zgradpulse(gzlvl1,gt1); delay(gstab); rgpulse(2*pw,v2,rof1,rof1); zgradpulse(gzlvl1,gt1); delay(gstab); zgradpulse(gzlvl2,gt2); delay(2.0*gstab); obspower(selpwrPS); rgradient('z',gzlvlPS); shaped_pulse(selshapePS,selpwPS,v3,rof1,rof1); rgradient('z',0.0); delay(gstab); obspower(tpwr); zgradpulse(gzlvl2,gt2); delay(gstab); if (d2>0) delay(d2/2.0-2.0*pw/PI-2.0*rof1); rgpulse(pw,v5,rof1,rof1); if (mixT > 0.0) { if (getflag("Gzqfilt")) { obspower(zqfpwr1); rgradient('z',gzlvlzq1); delay(100.0e-6); shaped_pulse(zqfpat1,zqfpw1,zero,rof1,rof1); delay(100.0e-6); rgradient('z',0.0); delay(100e-6); } obspower(slpwrT); zgradpulse(gzlvl3,gt3); delay(gt3); if (dps_flag) rgpulse(mixT,v4,0.0,0.0); else SpinLock(slpatT,mixT,slpwT,v4); if (getflag("Gzqfilt")) { obspower(zqfpwr2); rgradient('z',gzlvlzq2); delay(100.0e-6); shaped_pulse(zqfpat2,zqfpw2,zero,rof1,rof1); delay(100.0e-6); rgradient('z',0.0); delay(100e-6); } obspower(tpwr); zgradpulse(gzlvl4,gt4); delay(gt4); } rgpulse(pw,v8,rof1,rof2); status(C); }
pulsesequence() { double hsglvl = getval("hsglvl"), hsgt = getval("hsgt"), slpwT = getval("slpwT"), slpwrT = getval("slpwrT"), trim = getval("trim"), mixT = getval("mixT"), mult = getval("mult"), tau, null = getval("null"); char slpatT[MAXSTR]; int phase1 = (int)(getval("phase")+0.5); tau = 1/(4*(getval("j1xh"))); getstr("slpatT",slpatT); if (strcmp(slpatT,"mlev17c") && strcmp(slpatT,"dipsi2") && strcmp(slpatT,"dipsi3") && strcmp(slpatT,"mlev17") && strcmp(slpatT,"mlev16")) abort_message("SpinLock pattern %s not supported!.\n", slpatT); settable(t1,8,phs1); settable(t2,8,phs2); settable(t3,2,phs3); settable(t4,1,phs4); settable(t5,4,phs5); getelem(t3,ct,v6); getelem(t2,ct,oph); assign(two,v3); sub(v3,one,v2); add(v3,one,v4); add(v3,two,v5); /* mod2(id2,v14); dbl(v14,v14); */ initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14); if (phase1 == 2) incr(v6); add(v14, v6, v6); add(v14, oph, oph); /* BEGIN ACTUAL PULSE SEQUENCE CODE */ status(A); obspower(tpwr); delay(5.0e-5); if (getflag("sspul")) steadystate(); if (satmode[0] == 'y') { if ((d1-satdly) > 0.02) delay(d1-satdly); else delay(0.02); satpulse(satdly,zero,rof1,rof1); } else delay(d1); if (getflag("wet")) wet4(zero,one); decpower(pwxlvl); status(B); if ((getflag("PFGflg")) && (getflag("nullflg"))) { rgpulse(0.5*pw,zero,rof1,rof1); delay(2*tau); simpulse(2.0*pw,2.0*pwx,zero,zero,rof1,rof1); delay(2*tau); rgpulse(1.5*pw,two,rof1,rof1); zgradpulse(hsglvl,hsgt); delay(1e-3); } else if (null != 0.0) { rgpulse(pw,zero,rof1,rof1); delay(2*tau); simpulse(2*pw,2*pwx,zero,zero,rof1,rof1); delay(2*tau); rgpulse(pw,two,rof1,rof1); if (satmode[1] == 'y') satpulse(null,zero,rof1,rof1); else delay(null); } rgpulse(pw, t1, rof1, rof1); delay(2*tau - (2*pw/PI) - 2*rof1); decrgpulse(pwx, v6, rof1, 1.0e-6); if (d2 > 0.0) delay(d2/2.0 - pw - 3.0e-6 - (2*pwx/PI)); else delay(d2/2.0); rgpulse(2.0*pw, t4, 2.0e-6, 2.0e-6); if (d2 > 0.0) delay(d2/2.0 - pw - 3.0e-6 - (2*pwx/PI)); else delay(d2/2.0); decrgpulse(pwx, t5, 1.0e-6, rof1); obspower(slpwrT); decpower(dpwr); delay(2*tau - rof1 - 2*POWER_DELAY); if (mixT > 0.0) { rgpulse(trim,v5,0.0,0.0); if (dps_flag) rgpulse(mixT,v3,0.0,0.0); else SpinLock(slpatT,mixT,slpwT,v2,v3,v4,v5,v9); } if (mult > 0.5) { obspower(tpwr); obspower(pwxlvl); delay(2*tau - POWER_DELAY - rof1); simpulse(2*pw,mult*pwx,zero,zero,rof1,rof2); decpower(dpwr); delay(2*tau); } else delay(rof2); status(C); }
#include "../common/Structures.h" #include "../common/Packets.h" #include <sys/types.h> #include <sys/socket.h> #include <sys/epoll.h> #include <netinet/in.h> #include <fcntl.h> #include <errno.h> #include <unistd.h> #include <stdio.h> #include <string.h> #include <stdlib.h> int g_networkThreadCount = 0; SpinLock g_networkThreadCountLock = SpinLock(); NetworkManager::NetworkManager() : m_serverFd(0) { } NetworkManager::~NetworkManager() { for(int i=0; i<NETWORK_THREAD_NUM; i++) { delete m_epollEvent2DList[i]; } } bool NetworkManager::Initialize()
/* * @brief * BSP_GetSpinlock: 锁上给定ID的自旋锁。 * @param id:自旋锁编号 * @param[in] 无。 * @param[out] 无。 * @returns: 0,上锁成功。 * <p> -1,自旋锁ID不合法。 */ int BSP_GetSpinlock(int id) { return SpinLock(id); }
pulsesequence() { double slpwrT = getval("slpwrT"), slpwT = getval("slpwT"), trim = getval("trim"), mixT = getval("mixT"), gzlvlz = getval("gzlvlz"), gtz = getval("gtz"), zfphinc = getval("zfphinc"); char slpatT[MAXSTR]; int phase1 = (int)(getval("phase")+0.5); /* LOAD AND INITIALIZE VARIABLES */ getstr("slpatT",slpatT); if (strcmp(slpatT,"mlev17c") && strcmp(slpatT,"dipsi2") && strcmp(slpatT,"dipsi3") && strcmp(slpatT,"mlev17") && strcmp(slpatT,"mlev16")) abort_message("SpinLock pattern %s not supported!.\n", slpatT); /* mod2(id2,v14); dbl(v14,v14); */ initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14); sub(ct,ssctr,v12); settable(t1,4,ph1); getelem(t1,v12,v6); settable(t2,4,ph2); getelem(t2,v12,v1); settable(t3,8,ph3); settable(t4,4,ph4); getelem(t4,v12,v13); settable(t5,4,ph5); getelem(t5,v12,v2); settable(t7,8,ph7); getelem(t7,v12,v7); settable(t8,4,ph8); getelem(t8,v12,v8); assign(v1,oph); if (getflag("zfilt")) getelem(t3,v12,oph); sub(v2, one, v3); add(two, v2, v4); add(two, v3, v5); if (phase1 == 2) {incr(v1); incr(v6);} add(v1, v14, v1); add(v6, v14, v6); add(oph,v14,oph); /* The following is for flipback pulse */ zfphinc=zfphinc+180; if (zfphinc < 0) zfphinc=zfphinc+360; initval(zfphinc,v10); /* BEGIN ACTUAL PULSE SEQUENCE CODE */ status(A); obspower(tpwr); delay(5.0e-5); if (getflag("sspul")) steadystate(); if (satmode[0] == 'y') { if ((d1-satdly) > 0.02) delay(d1-satdly); else delay(0.02); satpulse(satdly,v6,rof1,rof1); } else delay(d1); if (getflag("wet")) wet4(zero,one); status(B); rgpulse(pw, v1, rof1, rof1); obspower(slpwrT); txphase(v13); if (d2 > 0.0) delay(d2 - rof1 - POWER_DELAY - (2*pw/PI)); else delay(d2); if (mixT > 0.0) { rgpulse(trim,v13,0.0,0.0); if (dps_flag) rgpulse(mixT,v3,0.0,0.0); else SpinLock(slpatT,mixT,slpwT,v2,v3,v4,v5, v9); } if ((getflag("zfilt")) && (getflag("PFGflg"))) { obspower(tpwr); rgpulse(pw,v7,1.0e-6,rof1); zgradpulse(gzlvlz,gtz); delay(gtz/3); if (getflag("flipback")) FBpulse(v8,v10); rgpulse(pw,v8,rof1,rof2); } else delay(rof2); status(C); }
/* * @brief * BSP_GetSpinlockIrqSaved: 锁上给定ID的自旋锁,保存之前上下文后关闭中断。 * @param id:自旋锁编号 * @param[in] 无。 * @param[out] 无。 * @returns: 0,上锁成功。 * <p> -1,自旋锁ID不合法。 */ int BSP_GetSpinlockIrqSaved(int id) { BSP_DisableIntIrqSave(); return SpinLock(id); }
pulsesequence() { double hsglvl = getval("hsglvl"), hsgt = getval("hsgt"), slpwT = getval("slpwT"), slpwrT = getval("slpwrT"), trim = getval("trim"), mixT = getval("mixT"), mult = getval("mult"), tau, null = getval("null"); char slpatT[MAXSTR]; int phase1 = (int)(getval("phase")+0.5), prgcycle = (int)(getval("prgcycle")+0.5); tau = 1/(4*(getval("j1xh"))); getstr("slpatT",slpatT); if (strcmp(slpatT,"mlev17c") && strcmp(slpatT,"dipsi2") && strcmp(slpatT,"dipsi3") && strcmp(slpatT,"mlev17") && strcmp(slpatT,"mlev16")) abort_message("SpinLock pattern %s not supported!.\n", slpatT); assign(ct,v17); assign(zero,v18); assign(zero,v19); if (getflag("prgflg") && (satmode[0] == 'y') && (prgcycle > 1.5)) { hlv(ct,v17); mod2(ct,v18); dbl(v18,v18); if (prgcycle > 2.5) { hlv(v17,v17); hlv(ct,v19); mod2(v19,v19); dbl(v19,v19); } } settable(t1,4,ph1); settable(t2,2,ph2); settable(t3,8,ph3); settable(t4,16,ph4); settable(t5,16,ph5); getelem(t1, v17, v1); getelem(t3, v17, v3); getelem(t4, v17, v4); getelem(t2, v17, v2); getelem(t5, v17, oph); assign(zero,v6); add(oph,v18,oph); add(oph,v19,oph); assign(two,v21); /* mod2(id2,v14); dbl(v14, v14); */ initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14); if (phase1 == 2) incr(v2); add(v2,v14,v2); add(oph,v14,oph); status(A); obspower(tpwr); delay(5.0e-5); if (getflag("sspul")) steadystate(); if (satmode[0] == 'y') { if ((d1-satdly) > 0.02) delay(d1-satdly); else delay(0.02); if (getflag("slpsat")) { shaped_satpulse("relaxD",satdly,zero); if (getflag("prgflg")) shaped_purge(v6,zero,v18,v19); } else { satpulse(satdly,zero,rof1,rof1); if (getflag("prgflg")) purge(v6,zero,v18,v19); } } else delay(d1); if (getflag("wet")) wet4(zero,one); decpower(pwxlvl); status(B); if ((getflag("PFGflg")) && (getflag("nullflg"))) { rgpulse(0.5*pw,zero,rof1,rof1); delay(2*tau); simpulse(2.0*pw,2.0*pwx,zero,zero,rof1,rof1); delay(2*tau); rgpulse(1.5*pw,two,rof1,rof1); zgradpulse(hsglvl,hsgt); delay(1e-3); } else if (null != 0.0) { rgpulse(pw,zero,rof1,rof1); delay(2*tau); simpulse(2*pw,2*pwx,zero,zero,rof1,rof1); delay(2*tau); rgpulse(pw,two,rof1,rof1); if (satmode[1] == 'y') { if (getflag("slpsat")) shaped_satpulse("BIRDnull",null,zero); else satpulse(null,zero,rof1,rof1); } else delay(null); } rgpulse(pw,v6,rof1,rof1); delay(tau - pwx - 2*pw/PI - 2*rof1); simpulse(2*pw,2*pwx,zero,zero,rof1,rof1); delay(tau - pwx - 2*pwx/PI - 2*rof1); rgpulse(pw,v1,rof1,rof1); if (getflag("PFGflg")) { zgradpulse(hsglvl,2*hsgt); delay(1.0e-3); } decrgpulse(pwx,v2,rof1,2.0e-6); if (d2/2 > 0.0) delay(d2/2 - (2*pwx/PI) - pw - 4.0e-6); else delay(d2/2); rgpulse(2*pw,zero,2.0e-6,2.0e-6); if (d2/2 > 0.0) delay(d2/2 - (2*pwx/PI) - pw - 4.0e-6); else delay(d2/2); decrgpulse(pwx,v4,2.0e-6,rof1); if (getflag("PFGflg")) { zgradpulse(-0.6*hsglvl,1.2*hsgt); delay(1.0e-3); } rgpulse(pw,v3,rof1,rof1); delay(tau - (2*pw/PI) - rof1); simpulse(2*pw,2*pwx,zero,zero,rof1, rof1); obspower(slpwrT); decpower(dpwr); delay(tau - rof1 - 2*POWER_DELAY); if (mixT > 0.0) { rgpulse(trim,zero,0.0,0.0); if (dps_flag) rgpulse(mixT,v21,0.0,0.0); else SpinLock(slpatT,mixT,slpwT,v21); } if (mult > 0.5) { obspower(tpwr); decpower(pwxlvl); delay(2*tau - POWER_DELAY - rof1); simpulse(2*pw,mult*pwx,zero,zero,rof1,rof2); decpower(dpwr); delay(2*tau); } else delay(rof2); status(C); }
virtual void OnThreadExecute(void) { SetThreadName("OVR::Capture"); while(m_listenSocket && !QuitSignaled()) { // try and accept a new socket connection... SocketAddress streamAddr; m_streamSocket = m_listenSocket->Accept(streamAddr); // If no connection was established, something went totally wrong and we should just abort... if(!m_streamSocket) break; // Before we start sending capture data... first must exchange connection headers... // First attempt to read in the request header from the Client... ConnectionHeaderPacket clientHeader = {0}; if(!m_streamSocket->Receive(&clientHeader, sizeof(clientHeader))) { m_streamSocket->Release(); m_streamSocket = NULL; continue; } // Load our connection flags... const UInt32 connectionFlags = clientHeader.flags & g_initFlags; // Build and send return header... We *always* send the return header so that if we don't // like something (like version number or feature flags), the client has some hint as to // what we didn't like. ConnectionHeaderPacket serverHeader = {0}; serverHeader.size = sizeof(serverHeader); serverHeader.version = ConnectionHeaderPacket::s_version; serverHeader.flags = connectionFlags; if(!m_streamSocket->Send(&serverHeader, sizeof(serverHeader))) { m_streamSocket->Release(); m_streamSocket = NULL; continue; } // Check version number... if(clientHeader.version != serverHeader.version) { m_streamSocket->Release(); m_streamSocket = NULL; continue; } // Check that we have any capture features even turned on... if(!connectionFlags) { m_streamSocket->Release(); m_streamSocket = NULL; continue; } // Finally, send our packet descriptors... const PacketDescriptorPacket packetDescs[] = { BuildPacketDescriptorPacket<ThreadNamePacket>(), BuildPacketDescriptorPacket<LabelPacket>(), BuildPacketDescriptorPacket<FramePacket>(), BuildPacketDescriptorPacket<VSyncPacket>(), BuildPacketDescriptorPacket<CPUZoneEnterPacket>(), BuildPacketDescriptorPacket<CPUZoneLeavePacket>(), BuildPacketDescriptorPacket<GPUZoneEnterPacket>(), BuildPacketDescriptorPacket<GPUZoneLeavePacket>(), BuildPacketDescriptorPacket<GPUClockSyncPacket>(), BuildPacketDescriptorPacket<SensorRangePacket>(), BuildPacketDescriptorPacket<SensorPacket>(), BuildPacketDescriptorPacket<FrameBufferPacket>(), BuildPacketDescriptorPacket<LogPacket>(), }; const PacketDescriptorHeaderPacket packetDescHeader = { sizeof(packetDescs) / sizeof(packetDescs[0]) }; if(!m_streamSocket->Send(&packetDescHeader, sizeof(packetDescHeader))) { m_streamSocket->Release(); m_streamSocket = NULL; continue; } if(!m_streamSocket->Send(&packetDescs, sizeof(packetDescs))) { m_streamSocket->Release(); m_streamSocket = NULL; continue; } // Connection established! // Signal that we are connected! AtomicExchange(g_connectionFlags, connectionFlags); // Technically any Labels that get initialized on another thread bettween the barrier and loop // will get sent over the network twice, but OVRMonitor will handle that. SpinLock(g_labelLock); for(Label *l=Label::GetHead(); l; l=l->GetNext()) { SendLabelPacket(*l); } SpinUnlock(g_labelLock); // Start CPU/GPU/Thermal sensors... StandardSensors stdsensors; if(CheckConnectionFlag(Enable_CPU_Clocks) || CheckConnectionFlag(Enable_GPU_Clocks) || CheckConnectionFlag(Enable_Thermal_Sensors)) { stdsensors.Start(); } // Spin as long as we are connected flushing data from our data stream... while(!QuitSignaled()) { const UInt64 flushBeginTime = GetNanoseconds(); if(!AsyncStream::FlushAll(*m_streamSocket)) { // Error occured... shutdown the connection. AtomicExchange(g_connectionFlags, (UInt32)0); m_streamSocket->Shutdown(); break; } const UInt64 flushEndTime = GetNanoseconds(); const UInt64 flushDeltaTime = flushEndTime - flushBeginTime; const UInt64 sleepTime = 5000000; // 5ms if(flushDeltaTime < sleepTime) { // Sleep just a bit to keep the thread from killing a core and to let a good chunk of data build up ThreadSleepNanoseconds(sleepTime - flushDeltaTime); } } // TODO: should we call AsyncStream::Shutdown() here??? // Close down our sensor thread... stdsensors.QuitAndWait(); // Connection was closed at some point, lets clean up our socket... m_streamSocket->Release(); m_streamSocket = NULL; } // while(m_listenSocket && !QuitSignaled()) }
// Dispatch function NTSTATUS DriverDispatch(DEVICE_OBJECT *device_object, IRP *irp) { NTSTATUS ret = STATUS_SUCCESS; IO_STACK_LOCATION *stack; void *buf; bool ok; // Validate arguments if (wfp == NULL || device_object == NULL || irp == NULL || wfp->Halting) { return NDIS_STATUS_FAILURE; } // Get the IRP stack stack = IoGetCurrentIrpStackLocation(irp); // Initialize the number of bytes irp->IoStatus.Information = 0; irp->IoStatus.Status = STATUS_SUCCESS; buf = irp->UserBuffer; if (wfp->Halting != FALSE) { // Device driver is terminating irp->IoStatus.Information = STATUS_UNSUCCESSFUL; IoCompleteRequest(irp, IO_NO_INCREMENT); return STATUS_UNSUCCESSFUL; } ok = false; // Branch to each operation switch (stack->MajorFunction) { case IRP_MJ_CREATE: // Open ok = true; break; case IRP_MJ_CLOSE: // Close ok = true; break; case IRP_MJ_READ: // Read ResetEvent(wfp->Event); break; case IRP_MJ_WRITE: // Write if ((stack->Parameters.Write.Length % sizeof(WFP_LOCAL_IP)) == 0) { // Address check bool check_ok = true; __try { ProbeForRead(buf, stack->Parameters.Write.Length, 1); } __except (EXCEPTION_EXECUTE_HANDLER) { check_ok = false; } if (check_ok) { MDL *mdl = IoAllocateMdl(buf, stack->Parameters.Write.Length, false, false, NULL); UINT size = MIN(WFP_MAX_LOCAL_IP_COUNT * sizeof(WFP_LOCAL_IP), stack->Parameters.Write.Length); UCHAR *copied_buf = Malloc(size); UCHAR *old_buf; if (mdl != NULL) { MmProbeAndLockPages(mdl, KernelMode, IoWriteAccess); } Copy(copied_buf, buf, size); SpinLock(wfp->LocalIPListLock); { old_buf = wfp->LocalIPListData; wfp->LocalIPListData = copied_buf; wfp->LocalIPListSize = size; } SpinUnlock(wfp->LocalIPListLock); if (old_buf != NULL) { Free(old_buf); } if (mdl != NULL) { MmUnlockPages(mdl); IoFreeMdl(mdl); } } } irp->IoStatus.Information = stack->Parameters.Write.Length; ok = true; break; }
pulsesequence() { double slpwrT = getval("slpwrT"), slpwT = getval("slpwT"), trim = getval("trim"), mixT = getval("mixT"), gzlvlz = getval("gzlvlz"), gtz = getval("gtz"), flippw = getval("flippw"), phincr1 = getval("phincr1"); char slpatT[MAXSTR], alt_grd[MAXSTR], flipback[MAXSTR]; int phase1 = (int)(getval("phase")+0.5); /* LOAD AND INITIALIZE VARIABLES */ // (void) set_RS(0); /* set up random sampling */ getstr("slpatT",slpatT); getstr("flipback", flipback); getstr("alt_grd",alt_grd); /* alternate gradient sign on every 2nd transient */ if (strcmp(slpatT,"mlev17c") && strcmp(slpatT,"dipsi2") && strcmp(slpatT,"dipsi3") && strcmp(slpatT,"mlev17") && strcmp(slpatT,"mlev16")) abort_message("SpinLock pattern %s not supported!.\n", slpatT); assign(ct,v17); initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14); settable(t1,4,ph1); getelem(t1,v17,v6); settable(t2,4,ph2); getelem(t2,v17,v1); settable(t3,8,ph3); settable(t4,4,ph4); getelem(t4,v17,v13); settable(t5,4,ph5); getelem(t5,v17,v21); settable(t7,8,ph7); getelem(t7,v17,v7); settable(t8,4,ph8); getelem(t8,v17,v8); settable(t11,16,phs8); getelem(t11,v6,v3); /* 1st echo in ES */ settable(t12,16,phs9); getelem(t12,v6,v4); /* 2nd exho in ES */ settable(t13,4,rec_cor); getelem(t13,v6,v9); assign(v1,oph); if (getflag("zfilt")) getelem(t3,v17,oph); if (phase1 == 2) {incr(v1); } add(v1, v14, v1); add(v6, v14, v6); add(oph,v14,oph); add(oph,v9,oph); mod4(oph,oph); /* correct oph for Excitation Sculpting */ /* The following is for flipback pulse */ if (phincr1 < 0.0) phincr1=360+phincr1; initval(phincr1,v10); if (alt_grd[0] == 'y') mod2(ct,v2); /* alternate gradient sign on even scans */ /* BEGIN ACTUAL PULSE SEQUENCE CODE */ status(A); if (getflag("lkgate_flg")) lk_sample(); /* turn lock sampling on */ obspower(tpwr); delay(5.0e-5); if (getflag("sspul")) steadystate(); delay(d1); if (getflag("lkgate_flg")) lk_hold(); /* turn lock sampling off */ status(B); rgpulse(pw, v1, rof1, rof1); obspower(slpwrT); txphase(v13); if (d2 > 0.0) delay(d2 - rof1 - POWER_DELAY - (2*pw/PI)); else delay(d2); if (mixT > 0.0) { rgpulse(trim,v13,0.0,0.0); if (dps_flag) rgpulse(mixT,v21,0.0,0.0); else SpinLock(slpatT,mixT,slpwT,v21); } if ((getflag("zfilt")) && (getflag("PFGflg"))) { obspower(tpwr); rgpulse(pw,v7,1.0e-6,rof1); ifzero(v2); zgradpulse(gzlvlz,gtz); elsenz(v2); zgradpulse(-gzlvlz,gtz); endif(v2); delay(gtz/3); if (getflag("flipback")) FlipBack(v8,v10); rgpulse(pw,v8,rof1,2.0e-6); } ExcitationSculpting(v3,v4,v2); delay(rof2); status(C); }
pulsesequence() { double slpwrT = getval("slpwrT"), slpwT = getval("slpwT"), mixT = getval("mixT"), trim = getval("trim"), tauz1 = getval("tauz1"), tauz2 = getval("tauz2"), tauz3 = getval("tauz3"), tauz4 = getval("tauz4"), selpwrA = getval("selpwrA"), selpwA = getval("selpwA"), gzlvlA = getval("gzlvlA"), gtA = getval("gtA"), selpwrB = getval("selpwrB"), selpwB = getval("selpwB"), gzlvlB = getval("gzlvlB"), gtB = getval("gtB"), gstab = getval("gstab"), selfrq = getval("selfrq"); char selshapeA[MAXSTR], selshapeB[MAXSTR], slpatT[MAXSTR], alt_grd[MAXSTR]; //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gtA = syncGradTime("gtA","gzlvlA",1.0); gzlvlA = syncGradLvl("gtA","gzlvlA",1.0); gtB = syncGradTime("gtB","gzlvlB",1.0); gzlvlB = syncGradLvl("gtB","gzlvlB",1.0); getstr("slpatT",slpatT); getstr("selshapeA",selshapeA); getstr("selshapeB",selshapeB); getstr("alt_grd",alt_grd); /* alternate gradient sign on every 2nd transient */ if (strcmp(slpatT,"mlev17c") && strcmp(slpatT,"dipsi2") && strcmp(slpatT,"dipsi3") && strcmp(slpatT,"mlev17") && strcmp(slpatT,"mlev16")) abort_message("SpinLock pattern %s not supported!.\n", slpatT); assign(ct,v17); assign(v17,v6); if (getflag("zqfilt")) { hlv(v6,v6); hlv(v6,v6); } settable(t1,4,ph1); getelem(t1,v6,v1); settable(t3,8,ph3); getelem(t3,v6,v11); settable(t4,8,ph4); settable(t5,4,ph5); getelem(t5,v6,v5); settable(t2,4,ph2); getelem(t2,v6,v2); settable(t7,8,ph7); getelem(t7,v6,v7); settable(t8,4,ph8); getelem(t8,v6,v8); settable(t11,16,phs8); getelem(t11,v6,v3); /* 1st echo in ES */ settable(t12,16,phs9); getelem(t12,v6,v4); /* 2nd exho in ES */ if (getflag("zqfilt")) getelem(t4,v6,oph); else assign(v1,oph); add(oph,v5,oph); mod4(oph,oph); sub(v2,one,v21); add(v21,two,v23); mod4(ct,v10); if (alt_grd[0] == 'y') mod2(ct,v12); /* alternate gradient sign on every 2nd transient */ /* BEGIN THE ACTUAL PULSE SEQUENCE */ status(A); if (getflag("lkgate_flg")) lk_sample(); /* turn lock sampling on */ obspower(tpwr); delay(5.0e-5); if (getflag("sspul")) steadystate(); delay(d1); if (getflag("lkgate_flg")) lk_hold(); /* turn lock sampling off */ status(B); rgpulse(pw, v1, rof1, rof1); if (selfrq != tof) obsoffset(selfrq); ifzero(v12); zgradpulse(gzlvlA,gtA); elsenz(v12); zgradpulse(-gzlvlA,gtA); endif(v12); delay(gstab); obspower(selpwrA); shaped_pulse(selshapeA,selpwA,v1,rof1,rof1); obspower(tpwr); ifzero(v12); zgradpulse(gzlvlA,gtA); elsenz(v12); zgradpulse(-gzlvlA,gtA); endif(v12); delay(gstab); if (selfrq != tof) delay(2*OFFSET_DELAY); ifzero(v12); zgradpulse(gzlvlB,gtB); elsenz(v12); zgradpulse(-gzlvlB,gtB); endif(v12); delay(gstab); obspower(selpwrB); shaped_pulse(selshapeB,selpwB,v2,rof1,rof1); obspower(slpwrT); ifzero(v12); zgradpulse(gzlvlB,gtB); elsenz(v12); zgradpulse(-gzlvlB,gtB); endif(v12); delay(gstab); if (selfrq != tof) obsoffset(tof); if (mixT > 0.0) { rgpulse(trim,v11,0.0,0.0); if (dps_flag) rgpulse(mixT,v21,0.0,0.0); else SpinLock(slpatT,mixT,slpwT,v21); } if (getflag("zqfilt")) { obspower(tpwr); rgpulse(pw,v7,1.0e-6,rof1); ifzero(v10); delay(tauz1); endif(v10); decr(v10); ifzero(v10); delay(tauz2); endif(v10); decr(v10); ifzero(v10); delay(tauz3); endif(v10); decr(v10); ifzero(v10); delay(tauz4); endif(v10); rgpulse(pw,v8,rof1,2.0e-6); } ExcitationSculpting(v3,v4,v12); delay(rof2); status(C); }
pulsesequence() { double slpwrR = getval("slpwrR"), slpwR = getval("slpwR"), mixR = getval("mixR"), gzlvlz = getval("gzlvlz"), gtz = getval("gtz"), zfphinc = getval("zfphinc"); char slpatR[MAXSTR]; int phase1 = (int)(getval("phase")+0.5); /* LOAD AND INITIALIZE PARAMETERS */ getstr("slpatR",slpatR); if (strcmp(slpatR,"cw") && strcmp(slpatR,"troesy") && strcmp(slpatR,"dante")) abort_message("SpinLock pattern %s not supported!.\n", slpatR); sub(ct,ssctr,v7); settable(t1,4,ph1); getelem(t1,v7,v1); settable(t2,8,ph2); getelem(t2,v7,v2); settable(t3,8,ph3); settable(t8,4,ph8); getelem(t8,v7,v8); settable(t6,8,ph6); getelem(t6,v7,v6); assign(v1,oph); if (getflag("zfilt")) getelem(t3,v7,oph); add(v2,one,v3); add(v2,two,v4); add(v2,three,v5); if (phase1 == 2) {incr(v1); incr(v6);} /* hypercomplex method */ /* mod2(id2,v13); dbl(v13,v13); */ initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v13); add(v1,v13,v1); add(v6,v13,v6); add(oph,v13,oph); /* The following is for flipback pulse */ zfphinc=zfphinc+180; if (zfphinc < 0) zfphinc=zfphinc+360; initval(zfphinc,v10); /* BEGIN ACTUAL PULSE SEQUENCE */ status(A); obspower(tpwr); delay(5.0e-5); if (getflag("sspul")) steadystate(); if (satmode[0] == 'y') { if ((d1-satdly) > 0.02) delay(d1-satdly); else delay(0.02); satpulse(satdly,v6,rof1,rof1); } else delay(d1); if (getflag("wet")) wet4(zero,one); decpower(dpwr); status(B); rgpulse(pw, v1, rof1, rof1); if (d2 > 0.0) delay(d2 - POWER_DELAY - (2*pw/PI) - rof1); else delay(d2); obspower(slpwrR); if (mixR > 0.0) { if (dps_flag) { if (!strcmp(slpatR,"troesy")) rgpulse(mixR,v2,0.0,0.0); else rgpulse(mixR,v3,0.0,0.0); } else SpinLock(slpatR,mixR,slpwR,v2,v3,v4,v5, v9); } if ((getflag("zfilt")) && (getflag("PFGflg"))) { obspower(tpwr); rgpulse(pw,v2,1.0e-6,rof1); zgradpulse(gzlvlz,gtz); delay(gtz/3); if (getflag("flipback")) FBpulse(v8,v10); rgpulse(pw,v8,rof1,rof2); } else delay(rof2); status(C); }
pulsesequence() { double slpwrR = getval("slpwrR"), slpwR = getval("slpwR"), mixR = getval("mixR"), selpwrA = getval("selpwrA"), selpwA = getval("selpwA"), gzlvlA = getval("gzlvlA"), gtA = getval("gtA"), selpwrB = getval("selpwrB"), selpwB = getval("selpwB"), gzlvlB = getval("gzlvlB"), gtB = getval("gtB"), gstab = getval("gstab"), selfrq = getval("selfrq"), gzlvl1 = getval("gzlvl1"), gt1 = getval("gt1"), gzlvl2 = getval("gzlvl2"), gt2 = getval("gt2"), zqfpw1 = getval("zqfpw1"), zqfpwr1 = getval("zqfpwr1"), gzlvlzq1 = getval("gzlvlzq1"), phincr1 = getval("phincr1"); char selshapeA[MAXSTR],selshapeB[MAXSTR], slpatR[MAXSTR], zqfpat1[MAXSTR], alt_grd[MAXSTR]; //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gtA = syncGradTime("gtA","gzlvlA",1.0); gzlvlA = syncGradLvl("gtA","gzlvlA",1.0); gtB = syncGradTime("gtB","gzlvlB",1.0); gzlvlB = syncGradLvl("gtB","gzlvlB",1.0); getstr("slpatR",slpatR); getstr("selshapeA",selshapeA); getstr("selshapeB",selshapeB); getstr("zqfpat1",zqfpat1); getstr("alt_grd",alt_grd); if (strcmp(slpatR,"cw") && strcmp(slpatR,"troesy") && strcmp(slpatR,"dante")) abort_message("SpinLock pattern %s not supported!.\n", slpatR); /* STEADY-STATE PHASECYCLING */ /* This section determines if the phase calculations trigger off of (SS - SSCTR) or off of CT */ assign(ct,v17); ifzero(ssctr); assign(v17,v13); elsenz(ssctr); /* purge option does not adjust v13 during steady state */ sub(ssval, ssctr, v13); endif(ssctr); /* Beginning phase cycling */ dbl(v13,v1); /* v1 = 0 2 */ hlv(v13,v13); dbl(v13,v20); /* v20 = 00 22 */ hlv(v13,v13); dbl(v13,v6); /* v6 = 0000 2222 */ hlv(v13,v13); dbl(v13,v7); /* v7 = 00000000 22222222 */ assign(v1,oph); if (getflag("Gzqfilt")) add(v7,oph,oph); /* CYCLOPS */ assign(v13,v14); /* v14 = 8x0 8x1 8x2 8x3 */ if (getflag("Gzqfilt")) hlv(v13,v14); /* v14 = 16x0 16x1 16x2 16x3 */ add(v1,v14,v1); add(v20,v14,v20); add(v6,v14,v6); add(v7,v14,v7); add(oph,v14,oph); /* add(oph,v18,oph); add(oph,v19,oph); */ assign(zero,v9); mod2(ct,v2); /* 01 01 */ hlv(ct,v11); hlv(v11,v11); mod2(v11,v11); dbl(v11,v11); /* 0000 2222 */ add(v11,v2,v11); mod4(v11,v11); /* 0101 2323 first echo in Excitation Sculpting */ hlv(ct,v4); mod2(v4,v4); /* 0011 */ hlv(ct,v12); hlv(v12,v12); hlv(v12,v12); dbl(v12,v12); add(v12,v4,v12); mod4(v12,v12); /* 0011 0011 2233 2233 second echo in Excitation Sculpting */ dbl(v2,v2); /* 0202 */ dbl(v4,v4); /* 0022 */ add(v2,v4,v4); /* 0220 correct oph for Excitation Sculpting */ add(oph,v4,oph); mod4(oph,oph); if (!strcmp(slpatR,"troesy")) assign(v20,v21); else add(v20,one,v21); if (alt_grd[0] == 'y') mod2(ct,v8); /* alternate gradient sign on even scans */ /* The following is for flipback pulse */ if (phincr1 < 0.0) phincr1=360+phincr1; initval(phincr1,v5); /* BEGIN THE ACTUAL PULSE SEQUENCE */ status(A); if (getflag("lkgate_flg")) lk_sample(); /* turn lock sampling on */ obspower(tpwr); delay(5.0e-5); if (getflag("sspul")) steadystate(); delay(d1); if (getflag("lkgate_flg")) lk_hold(); /* turn lock sampling off */ status(B); rgpulse(pw, v1, rof1, rof1); if (selfrq != tof) obsoffset(selfrq); ifzero(v8); zgradpulse(gzlvlA,gtA); elsenz(v8); zgradpulse(-gzlvlA,gtA); endif(v8); delay(gstab); obspower(selpwrA); shaped_pulse(selshapeA,selpwA,v14,rof1,rof1); obspower(tpwr); ifzero(v8); zgradpulse(gzlvlA,gtA); elsenz(v8); zgradpulse(-gzlvlA,gtA); endif(v8); delay(gstab); if (selfrq != tof) delay(2*OFFSET_DELAY); ifzero(v8); zgradpulse(gzlvlB,gtB); elsenz(v8); zgradpulse(-gzlvlB,gtB); endif(v8); delay(gstab); obspower(selpwrB); shaped_pulse(selshapeB,selpwB,v6,rof1,rof1); obspower(slpwrR); ifzero(v8); zgradpulse(gzlvlB,gtB); elsenz(v8); zgradpulse(-gzlvlB,gtB); endif(v8); delay(gstab); if (selfrq != tof) obsoffset(tof); if (mixR > 0.0) { if (dps_flag) rgpulse(mixR,v21,0.0,0.0); else SpinLock(slpatR,mixR,slpwR,v21); } if (getflag("Gzqfilt")) { obspower(tpwr); rgpulse(pw,v7,rof1,rof1); ifzero(v8); zgradpulse(gzlvl1,gt1); elsenz(v8); zgradpulse(-gzlvl1,gt1); endif(v8); delay(gstab); obspower(zqfpwr1); ifzero(v8); rgradient('z',gzlvlzq1); elsenz(v8); rgradient('z',-gzlvlzq1); endif(v8); delay(100.0e-6); shaped_pulse(zqfpat1,zqfpw1,zero,rof1,rof1); delay(100.0e-6); rgradient('z',0.0); delay(gstab); ifzero(v8); zgradpulse(-gzlvl2,gt2); elsenz(v8); zgradpulse(gzlvl2,gt2); endif(v8); obspower(tpwr); delay(gstab); if (getflag("flipback")) FlipBack(v14,v5); rgpulse(pw,v14,rof1,2.0e-6); } ExcitationSculpting(v11,v12,v8); delay(rof2); status(C); }
pulsesequence() { double gzlvlE = getval("gzlvlE"), gtE = getval("gtE"), EDratio = getval("EDratio"), gstab = getval("gstab"), hsglvl = getval("hsglvl"), hsgt = getval("hsgt"), slpwT = getval("slpwT"), slpwrT = getval("slpwrT"), trim = getval("trim"), mixT = getval("mixT"), mult = getval("mult"), tau, gtau; int icosel, phase1 = (int)(getval("phase")+0.5); char slpatT[MAXSTR]; //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gtE = syncGradTime("gtE","gzlvlE",0.5); gzlvlE = syncGradLvl("gtE","gzlvlE",0.5); getstr("slpatT",slpatT); if (strcmp(slpatT,"mlev17c") && strcmp(slpatT,"dipsi2") && strcmp(slpatT,"dipsi3") && strcmp(slpatT,"mlev17") && strcmp(slpatT,"mlev16")) abort_message("SpinLock pattern %s not supported!.\n", slpatT); tau = 1/(4*(getval("j1xh"))); gtau = 2*gstab + 2*GRADIENT_DELAY; icosel = 1; settable(t1,2,ph1); settable(t2,4,ph2); settable(t3,4,ph3); assign(zero,v6); getelem(t1,ct,v1); getelem(t3,ct,oph); assign(two,v3); sub(v3,one,v2); add(v3,one,v4); add(v3,two,v5); /* mod2(id2,v14); dbl(v14,v14); */ initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14); if ((phase1 == 2) || (phase1 == 5)) icosel = -1; add(v1,v14,v1); add(v6,v14,v6); add(oph,v14,oph); status(A); obspower(tpwr); delay(5.0e-5); if (getflag("sspul")) steadystate(); if (satmode[0] == 'y') { if ((d1-satdly) > 0.02) delay(d1-satdly); else delay(0.02); satpulse(satdly,zero,rof1,rof1); } else delay(d1); if (getflag("wet")) wet4(zero,one); decpower(pwxlvl); status(B); if (getflag("nullflg")) { rgpulse(0.5*pw,zero,rof1,rof1); delay(2*tau); simpulse(2.0*pw,2.0*pwx,zero,zero,rof1,rof1); delay(2*tau); rgpulse(1.5*pw,two,rof1,rof1); zgradpulse(hsglvl,hsgt); delay(1e-3); } rgpulse(pw,zero,rof1,rof1); delay(2*tau - 2*rof1 - (2*pw/PI)); decrgpulse(pwx,v1,rof1,1.0e-6); delay(gtE/2.0+gtau - (2*pwx/PI) - pwx - 1.0e-6 - rof1); decrgpulse(2*pwx,v6,rof1,1.0e-6); delay(gstab - pwx - 1.0e-6); zgradpulse(gzlvlE,gtE/2.0); delay(gstab - rof1 - pw); delay(d2/2); rgpulse(2.0*pw,zero,rof1,rof1); delay(d2/2); delay(gstab - rof1 - pw); zgradpulse(gzlvlE,gtE/2.0); delay(gstab - pwx - rof1); decrgpulse(2*pwx,zero,rof1,1.0e-6); delay(gtE/2.0+gtau - (2*pwx/PI) - pwx - 1.0e-6 - rof1); decrgpulse(pwx,t2,rof1,rof1); delay(2*tau - rof1 - POWER_DELAY); obspower(slpwrT); if (mixT > 0.0) { rgpulse(trim,v5,0.0,0.0); if (dps_flag) rgpulse(mixT,v3,0.0,0.0); else SpinLock(slpatT,mixT,slpwT,v2,v3,v4,v5,v9); } obspower(tpwr); if (mult > 0.5) delay(2*tau - rof1); else delay(gtE/2 + gstab + 2*GRADIENT_DELAY - rof1); simpulse(2*pw,mult*pwx,one,zero,rof1,rof2); decpower(dpwr); zgradpulse(icosel*2*gzlvlE/EDratio,gtE/2.0); if (mult > 0.5) delay(2*tau - gtE/2 - 2*GRADIENT_DELAY); else delay(gstab); status(C); }