void __fastcall TForm1::Button1Click(TObject *Sender)
{
char TextString[256];
unsigned int UniqueID = CSpinEdit1->Value;
int StartPercent, cnt;
CGauge1->Progress = 0;
//config data pins as output
OutputPort(nAddress+2, InputPort(nAddress+2)&0xDF);
//Enable buffers
SetOE(1);
//Start programming
SetMOSI(0);
SetSCK(0);
SetReset(0);
Sleep(1);
SetReset(1);
for (cnt=0; cnt<50; cnt++)
{
CGauge1->AddProgress(1);
Sleep(75);
}
StartPercent = CGauge1->PercentDone;
for (cnt=0; cnt<16; cnt++)
{
SetMOSI((bool)(UniqueID&(0x8000>>cnt)));
SetSCK(1);
Sleep(1);
SetSCK(0);
Sleep(1);
CGauge1->AddProgress(((100-StartPercent)*cnt)/32);
}
unsigned int ControlValue = 0xAC5A;
for (cnt=0; cnt<16; cnt++)
{
SetMOSI((bool)(ControlValue&(0x8000>>cnt)));
SetSCK(1);
Sleep(1);
SetSCK(0);
Sleep(1);
CGauge1->AddProgress(((100-StartPercent)*cnt)/32);
}
Sleep(100);
//Start reset
SetMOSI(0);
SetSCK(0);
SetReset(0);
Sleep(1);
SetReset(1);
//Disable buffers
SetOE(0);
}
void CLogManager::ResetLogData(uint16 u2LogLevel)
{
//重新设置日志等级，加载日志文件
SetReset(true);
//这里等待一段时间，等待其他日志全部写入完成，在重载日志模块。
//这样做少加一个锁
ACE_Time_Value tvSleep(0, 1000);
ACE_OS::sleep(tvSleep);
m_pServerLogger->ReSet(u2LogLevel);
SetReset(false);
}
void __fastcall TForm1::Button2Click(TObject *Sender)
{
//config data pins as output
OutputPort(nAddress+2, InputPort(nAddress+2)&0xDF);
//Enable buffers
SetOE(1);
//Start reset
SetMOSI(0);
SetSCK(0);
SetReset(0);
Sleep(1);
SetReset(1);
//Disable buffers
SetOE(0);
}
int CLogManager::Start()
{
if(m_blRun == true)
{
return 0;
}
else
{
SetReset(false);
return open();
}
}
static Stacklet_t*
Stacklet_Alloc(StackChain_t* stackChain)
{
int i;
Stacklet_t *res = NULL;
/*
Each stacklet contains the primary and replica. Each one
starts with a guard page, a C area, and then an ML area.
*/
int size = (GuardStackletSize + MLStackletSize + CStackletSize) * kilobyte; /* for just one of the two: primary and replica */
assert(stackletOffset == size);
for (i=0; i<NumStacklet; i++)
if (CompareAndSwap(&Stacklets[i].count, 0, 1) == 0) {
res = &Stacklets[i];
break;
}
if (res == NULL)
DIE("out of stack space");
res->parent = stackChain;
res->state = Inconsistent;
if (!res->mapped) {
mem_t start = my_mmap(2 * size, PROT_READ | PROT_WRITE);
mem_t middle = start + size / (sizeof (val_t));
res->baseExtendedBottom = start +
(GuardStackletSize * kilobyte) / (sizeof (val_t));
res->baseBottom = res->baseExtendedBottom +
(CStackletSize * kilobyte) / (sizeof (val_t));
res->baseTop = res->baseBottom +
(MLStackletSize * kilobyte) / (sizeof (val_t));
assert(res->baseTop == middle);
/*
Get some initial room in multiples of 64 bytes; Sparc
requires at least 68 byte for the save area.
*/
res->baseTop -= (128 / sizeof(val_t));
my_mprotect(0, (caddr_t) start, GuardStackletSize * kilobyte,
PROT_NONE); /* Guard page at bottom of primary */
my_mprotect(1, (caddr_t) middle, GuardStackletSize * kilobyte,
PROT_NONE); /* Guard page at bottom of replica */
res->callinfoStack = SetCreate(size / (32 * sizeof (val_t)));
res->mapped = 1;
}
res->baseCursor = res->baseTop;
for (i=0; i<32; i++)
res->bottomBaseRegs[i] = 0;
SetReset(res->callinfoStack);
return res;
}
int SPIBus::Reset(void)
{
UserDebug(UserApp2, "SPIBus::Reset() I\n");
SetDelay();
clearSCK(); // Dal datasheet AVR
setMOSI(); // the datasheet don't specify, but we need to provide power from at least one line (MOSI while SCK and RESET are low)
WaitMsec(20);
ClearReset(); //One pulse on the reset (datasheet AVR)
WaitMsec( THEAPP->GetSPIResetPulse() ); //AppNote AVR910 suggest >100 msec
SetReset();
WaitMsec( THEAPP->GetSPIDelayAfterReset() );
UserDebug(UserApp2, "SPIBus::Reset() O\n");
return OK;
}
void CModifiedEditBox::SetChanged (bool Changed)
{
m_Changed = Changed;
if (m_Changed)
{
SetReset(false);
if (m_BoldFont == NULL)
{
m_OriginalFont = (HFONT)SendMessage(WM_GETFONT);
LOGFONT lfSystemVariableFont;
GetObject ( m_OriginalFont, sizeof(LOGFONT), &lfSystemVariableFont );
lfSystemVariableFont.lfWeight = FW_BOLD;
m_BoldFont = CreateFontIndirect ( &lfSystemVariableFont );
}
SendMessage(WM_SETFONT,(WPARAM)m_BoldFont);
InvalidateRect(NULL);
if (m_TextField)
{
::SendMessage(m_TextField,WM_SETFONT,(WPARAM)m_BoldFont,0);
::InvalidateRect(m_TextField, NULL, true);
}
} else {
if (m_OriginalFont)
{
SendMessage(WM_SETFONT,(WPARAM)m_OriginalFont);
InvalidateRect(NULL);
if (m_TextField)
{
::SendMessage(m_TextField,WM_SETFONT,(WPARAM)m_OriginalFont,0);
::InvalidateRect(m_TextField, NULL, true);
}
}
}
}
/* Copy primary into replica */
int
Stacklet_Copy(Stacklet_t* stacklet)
{
StackletState_t state;
state = CompareAndSwap((int*) &stacklet->state, Pending, Copying);
if (state == Pending) {
int i;
int activeSize = (stacklet->baseTop - stacklet->baseCursor) *
sizeof(val_t);
mem_t primaryCursor = stacklet->baseCursor +
(primaryStackletOffset / sizeof(val_t));
mem_t replicaCursor = stacklet->baseCursor +
(replicaStackletOffset / sizeof(val_t));
volatile reg_t* primaryRegs = &stacklet->bottomBaseRegs
[primaryStackletOffset == 0 ? 0 : 32];
volatile reg_t* replicaRegs = &stacklet->bottomBaseRegs
[primaryStackletOffset == 0 ? 32 : 0];
assert(stacklet->count > 0);
assert(stacklet->baseExtendedBottom <= stacklet->baseCursor);
assert(stacklet->baseCursor <= stacklet->baseTop);
SetReset(stacklet->callinfoStack);
stacklet->replicaCursor = stacklet->baseCursor;
stacklet->replicaRetadd = stacklet->retadd;
memcpy(replicaCursor, primaryCursor, activeSize);
for (i=0; i<32; i++)
replicaRegs[i] = primaryRegs[i];
stacklet->state = InactiveCopied;
return 1;
}
while (stacklet->state == Copying)
;
assert(stacklet->state != Inconsistent);
assert(stacklet->state != Pending);
return 0;
}
void
SetTransfer(Set_t* from, Set_t* to) /* destructive operation on from */
{
SetCopy(from,to);
SetReset(from);
}
static void do_work(Proc_t *proc, int additionalWork)
{
Heap_t *srcRange = (GCType == Minor) ? nursery : fromSpace;
if (additionalWork <= 0)
return;
addMaxWork(proc, additionalWork);
procChangeState(proc, GCWork, 612);
proc->segmentType |= (GCType == Major) ? MajorWork : MinorWork;
if (collectDiag >= 2)
printf("GC %4d/%6d: Entered do_work(%d) updateWorkDone = %5d\n",
NumGC, proc->segmentNumber, additionalWork, updateGetWorkDone(proc));
while (!reachMaxWork(proc)) {
ploc_t rootLoc, globalLoc, backLoc;
ptr_t backObj, gray;
int largeStart, largeEnd;
Stacklet_t *stacklet;
/* Get shared work */
popSharedStack(workStack, &proc->work);
if ((GCStatus == GCPendingOn || GCStatus == GCPendingOff) &&
isLocalWorkEmpty(&proc->work))
break;
/* Do the thread stacklets - we can afford to call updateWorkDone often */
while (!reachCheckWork(proc) &&
((stacklet = (Stacklet_t *) SetPop(&proc->work.stacklets)) != NULL)) {
if (!work_root_scan(proc, stacklet))
SetPush(&proc->work.stacklets, (ptr_t) stacklet);
}
/* Do the rootLocs */
if (GCType == Minor) {
while (!reachCheckWork(proc) &&
((rootLoc = (ploc_t) SetPop(&proc->work.roots)) != NULL)) {
locAlloc1_copyCopySync_primarySet(proc,rootLoc,srcRange);
proc->segUsage.fieldsScanned++;
}
}
else {
while (!reachCheckWork(proc) &&
((rootLoc = (ploc_t) SetPop(&proc->work.roots)) != NULL)) {
locAlloc1L_copyCopySync_primarySet(proc,rootLoc,srcRange,largeSpace);
proc->segUsage.fieldsScanned++;
}
}
/* Do the backObjs and backLocs */
if (GCType == Minor) {
while (!updateReachCheckWork(proc) &&
((backObj = (ptr_t) SetPop(&proc->work.backObjs)) != NULL)) {
selfTransferScanObj_locAlloc1_copyCopySync_primarySet(proc,backObj,srcRange);
}
while (!reachCheckWork(proc) &&
((backLoc = (ploc_t) SetPop(&proc->work.backLocs)) != NULL)) {
ploc_t mirrorBackLoc = backLoc + ((primaryArrayOffset == 0) ? 1 : -1);
*mirrorBackLoc = *backLoc;
locAlloc1_copyCopySync_primarySet(proc,mirrorBackLoc,srcRange);
proc->segUsage.fieldsScanned += 2;
}
}
else {
SetReset(&proc->work.backObjs);
SetReset(&proc->work.backLocs);
}
/* Do the globalLocs */
if (GCType == Minor)
while (!reachCheckWork(proc) &&
((globalLoc = (ploc_t) SetPop(&proc->work.globals)) != NULL)) {
ploc_t replicaLoc = (ploc_t) DupGlobal((ptr_t) globalLoc);
locAlloc1_copyCopySync_primarySet(proc,replicaLoc,srcRange);
proc->segUsage.globalsProcessed++;
}
else
while (!reachCheckWork(proc) &&
((globalLoc = (ploc_t) SetPop(&proc->work.globals)) != NULL)) {
ploc_t replicaLoc = (ploc_t) DupGlobal((ptr_t) globalLoc);
locAlloc1L_copyCopySync_primarySet(proc,replicaLoc,srcRange,largeSpace);
proc->segUsage.globalsProcessed++;
}
/* Do the large objects - don't need to optimize loop */
while (!updateReachCheckWork(proc) &&
(gray = SetPop3(&proc->work.segments,(ptr_t *)&largeStart,(ptr_t *)&largeEnd))) {
if (GCType == Minor) {
int isMirrorPtrArray = (GET_TYPE(gray[-1]) == MIRROR_PTR_ARRAY_TYPE);
if (isMirrorPtrArray) {
fastAssert(inHeap(gray, fromSpace));
selfTransferScanSegment_copyWriteSync_locAlloc1_copyCopySync_primarySet(proc,gray,largeStart,largeEnd,srcRange);
}
else
transferScanSegment_copyWriteSync_locAlloc1_copyCopySync_primarySet(proc,gray,largeStart,largeEnd,srcRange);
}
else
transferScanSegment_copyWriteSync_locAlloc1L_copyCopySync_primarySet(proc,gray,largeStart,largeEnd,srcRange, largeSpace);
}
/* Work on the gray objects */
if (GCType == Minor)
while (!reachCheckWork(proc) &&
((gray = SetPop(&proc->work.objs)) != NULL))
transferScanObj_copyWriteSync_locAlloc1_copyCopySync_primarySet(proc,gray,srcRange);
else
while (!reachCheckWork(proc) &&
((gray = SetPop(&proc->work.objs)) != NULL))
transferScanObj_copyWriteSync_locAlloc1L_copyCopySync_primarySet(proc,gray,srcRange,largeSpace);
/* Put work back on shared stack */
if (pushSharedStack(0,workStack,&proc->work)) {
if (GCStatus == GCAgressive)
GCStatus = GCPendingOn;
else if (GCStatus == GCOn)
GCStatus = GCPendingOff;
}
}
assert(isLocalWorkEmpty(&proc->work));
if (collectDiag >= 2)
printf("GC %d Seg %d: Completed do_work(%d) segWork = %5d sharedStack(%4ld items %2ld segs) %ld alloc %ld copied\n",
NumGC, proc->segmentNumber, additionalWork, updateGetWorkDone(proc),
SetLength(&workStack->work.objs), SetLength(&workStack->work.segments),
proc->cycleUsage.bytesAllocated + proc->segUsage.bytesAllocated,
bytesCopied(&proc->cycleUsage) + bytesCopied(&proc->segUsage));
}
void
discardNextSharedStack(SharedStack_t* ss)
{
SetReset(&ss->work.nextBackObjs);
SetReset(&ss->work.nextBackLocs);
}
