自学教程：C++ GLOBAL_LOCK函数代码示例

HRESULT CLR_HW_Hardware::TransferAllInterruptsToApplicationQueue(){    NATIVE_PROFILE_CLR_HARDWARE();    TINYCLR_HEADER();    while(true)    {        HalInterruptRecord* rec;        {            GLOBAL_LOCK(irq1);            rec = m_interruptData.m_HalQueue.Peek();        }        if(rec == NULL) break;        CLR_RT_ApplicationInterrupt* queueRec = (CLR_RT_ApplicationInterrupt*)CLR_RT_Memory::Allocate_And_Erase( sizeof(CLR_RT_ApplicationInterrupt), CLR_RT_HeapBlock::HB_CompactOnFailure );  CHECK_ALLOCATION(queueRec);        queueRec->m_interruptPortInterrupt.m_data1   =                                          rec->m_data1;        queueRec->m_interruptPortInterrupt.m_data2   =                                          rec->m_data2;        queueRec->m_interruptPortInterrupt.m_data3   =                                          rec->m_data3;        queueRec->m_interruptPortInterrupt.m_time    =                                          rec->m_time;        queueRec->m_interruptPortInterrupt.m_context = (CLR_RT_HeapBlock_NativeEventDispatcher*)rec->m_context;        m_interruptData.m_applicationQueue.LinkAtBack( queueRec ); ++m_interruptData.m_queuedInterrupts;        {            GLOBAL_LOCK(irq2);                        m_interruptData.m_HalQueue.Pop();        }    }    if(m_interruptData.m_queuedInterrupts == 0)    {        TINYCLR_SET_AND_LEAVE(CLR_E_NO_INTERRUPT);    }    TINYCLR_CLEANUP();    if(CLR_E_OUT_OF_MEMORY == hr)    {        // if there is no memory left discard all interrupts to avoid getting into a death spiral of OOM exceptions        {            GLOBAL_LOCK(irq3);            while(!m_interruptData.m_HalQueue.IsEmpty())            {                m_interruptData.m_HalQueue.Pop();            }        }    }            TINYCLR_CLEANUP_END();}

int USART_Driver::Read( int ComPortNum, char* Data, size_t size ){    NATIVE_PROFILE_PAL_COM();    if((ComPortNum < 0) || (ComPortNum >= TOTAL_USART_PORT)) {ASSERT(FALSE); return -1;}    if(Data == NULL                                        )                 return -1;    HAL_USART_STATE& State = Hal_Usart_State[ComPortNum];    if ( IS_POWERSAVE_ENABLED(State) || (!IS_USART_INITIALIZED(State))) return -1;    int CharsRead = 0;    while(CharsRead < size)    {        // keep interrupts off only during pointer movement so we are atomic        GLOBAL_LOCK(irq);        size_t toRead;        UINT8 *Src;        toRead = size - CharsRead;        Src = State.RxQueue.Pop( toRead );        if( NULL == Src )            break;        // Check if FIFO level has just passed or gotten down to the low water mark        if(State.RxQueue.NumberOfElements() <= State.RxBufferLowWaterMark && (State.RxQueue.NumberOfElements() + toRead) > State.RxBufferLowWaterMark)        {            if( USART_FLAG_STATE(State, HAL_USART_STATE::c_RX_SWFLOW_CTRL) )            {                // Clear our XOFF state                SendXON( ComPortNum, XOFF_FLAG_FULL );            }            if( USART_FLAG_STATE(State, HAL_USART_STATE::c_RX_HWFLOW_CTRL) )            {                CPU_USART_RxBufferFullInterruptEnable(ComPortNum, TRUE);            }        }        memcpy(&Data[CharsRead], Src, toRead);   // Copy data from queue to Read buffer        CharsRead += toRead;    }    {        GLOBAL_LOCK(irq);             State.fDataEventSet  = FALSE;                if(!State.RxQueue.IsEmpty())        {            SetEvent( ComPortNum, USART_EVENT_DATA_CHARS );        }     }    return CharsRead;}

void HAL_COMPLETION::DequeueAndExec(){    NATIVE_PROFILE_PAL_ASYNC_PROC_CALL();    GLOBAL_LOCK(irq);    HAL_COMPLETION* ptr     = (HAL_COMPLETION*)g_HAL_Completion_List.FirstNode();    HAL_COMPLETION* ptrNext = (HAL_COMPLETION*)ptr->Next();    // waitforevents does not have an associated completion, therefore we need to verify    // than their is a next completion and that the current one has expired.    if(ptrNext)    {        ASSERT(ptr->EventTimeTicks <= HAL_Time_CurrentTicks());                Events_Set(SYSTEM_EVENT_FLAG_SYSTEM_TIMER);        ptr->Unlink();        //        // In case there's no other request to serve, set the next interrupt to be 356 years since last powerup (@25kHz).        //        HAL_Time_SetCompare( ptrNext->Next() ? ptrNext->EventTimeTicks : HAL_Completion_IdleValue );#if defined(_DEBUG)        ptr->EventTimeTicks = 0;#endif  // defined(_DEBUG)        // let the ISR turn on interrupts, if it needs to        ptr->Execute();    }}

void Events_Clear( UINT32 Events ){    NATIVE_PROFILE_PAL_EVENTS();    GLOBAL_LOCK(irq);    SystemEvents &= ~Events;}

BOOL USART_Driver::ConnectEventSink( int ComPortNum, int EventType, void* pContext, PFNUsartEvent pfnUsartEvtHandler, void** ppArg ){    if((ComPortNum < 0) || (ComPortNum >= TOTAL_USART_PORT)) return FALSE;    {        GLOBAL_LOCK(irq);        HAL_USART_STATE& State = Hal_Usart_State[ComPortNum];        State.PortIndex = ComPortNum;                if(ppArg != NULL) *ppArg = (void*)ComPortNum;        if(EventType == USART_EVENT_TYPE_DATA)        {            State.UsartDataEventCallback = pfnUsartEvtHandler;            State.DataContext            = pContext;        }        else if(EventType == USART_EVENT_TYPE_ERROR)        {            State.UsartErrorEventCallback = pfnUsartEvtHandler;            State.ErrorContext            = pContext;        }    }    return TRUE;}

BOOL MC9328MXL_AITC_Driver::ActivateInterrupt( UINT32 Irq_Index, BOOL Fast, HAL_CALLBACK_FPN ISR, void* ISR_Param, UINT8 Priority ){    // figure out the interrupt    IRQ_VECTORING* IsrVector = IRQToIRQVector( Irq_Index ); if(!IsrVector) return FALSE;    {        GLOBAL_LOCK(irq);        MC9328MXL_AITC& AITC = MC9328MXL::AITC();        // disable this interrupt while we change it        AITC.INTDISNUM = IsrVector->Index;        // set the correct type        AITC.SetType( IsrVector->Index, Fast );        // set the correct priority        AITC.SetPriority( IsrVector->Index, Priority );        // set the vector        IsrVector->Handler.Initialize( ISR, ISR_Param );        // enable the interrupt if we have a vector        AITC.INTENNUM = IsrVector->Index;    }    return TRUE;}

void LPC22XX_USART_Driver::TxBufferEmptyInterruptEnable( int ComPortNum, BOOL Enable  ){    GLOBAL_LOCK(irq);    LPC22XX_USART& USARTC = LPC22XX::UART(ComPortNum);        ASSERT(LPC22XX_USART_Driver::IsValidPortNum(ComPortNum));        if (Enable)    {       USARTC.SEL2.IER.UART_IER |=  (LPC22XX_USART::UART_IER_THREIE);              char c;        for (int i=0; i<2; i++)        {            if (USART_RemoveCharFromTxBuffer( ComPortNum, c ))            {                WriteCharToTxBuffer( ComPortNum, c );                Events_Set( SYSTEM_EVENT_FLAG_COM_OUT );            }            else                break;        }           }    else    {       USARTC.SEL2.IER.UART_IER &= ~(LPC22XX_USART::UART_IER_THREIE);                  }}

BOOL LPC22XX_GPIO_Driver::Uninitialize(){    GLOBAL_LOCK(irq);// TODO Implementation    return TRUE;}

void AT91_GPIO_Driver::EnableOutputPin( GPIO_PIN pin, BOOL initialState ){        UINT32   bitmask  = 1 << PinToBit( pin );    UINT32  port = PinToPort( pin );    AT91_PIO &pioX = AT91::PIO (port);    GLOBAL_LOCK(irq);    pioX.PIO_PER = bitmask;                   // Enable PIO function            if(initialState)        pioX.PIO_SODR = bitmask;    else        pioX.PIO_CODR = bitmask;    pioX.PIO_OER = bitmask;                   // Enable Output    PIN_ISR_DESCRIPTOR& pinIsr = g_AT91_GPIO_Driver.m_PinIsr[ pin ];    pinIsr.m_intEdge = GPIO_INT_NONE;    pinIsr.m_isr     = STUB_GPIOISRVector;    pinIsr.m_param   = NULL;}

BOOL LPC24XX_VIC_Driver::ActivateInterrupt( UINT32 Irq_Index, BOOL Fast, HAL_CALLBACK_FPN ISR, void* ISR_Param ){    // figure out the interrupt    IRQ_VECTORING* IsrVector = IRQToIRQVector( Irq_Index ); if(!IsrVector) return FALSE;    {        GLOBAL_LOCK(irq);        LPC24XX_VIC& VIC = LPC24XX::VIC();        // disable this interrupt while we change it        VIC.INTENCLR = 1 << IsrVector->Index;        // set the vector        IsrVector->Handler.Initialize( ISR, ISR_Param );                // Use Vector Address register to identify the source of interrupt        VIC.VECTADDR[Irq_Index] = Irq_Index;        // enable the interrupt if we have a vector        VIC.INTENABLE = 1 << IsrVector->Index;    }    return TRUE;}

void I2C_Driver::Cancel( I2C_HAL_XACTION* xAction, bool signal ){    NATIVE_PROFILE_PAL_COM();    ASSERT(xAction);        if(xAction == NULL) return;        GLOBAL_LOCK(irq);       switch(xAction->GetState())    {        // only one xAction will efer be in processing for every call to Abort        case I2C_HAL_XACTION::c_Status_Processing:                        I2C_Internal_XActionStop();            // fall through...        case I2C_HAL_XACTION::c_Status_Scheduled:        case I2C_HAL_XACTION::c_Status_Completed:        case I2C_HAL_XACTION::c_Status_Aborted:            xAction->Abort();            xAction->SetState(I2C_HAL_XACTION::c_Status_Cancelled);            StartNext();                        break;        case I2C_HAL_XACTION::c_Status_Idle: // do nothing since we aren't enqueued yet            break;    }}

	/*---------------------------------------------------------------------------*/	int TTWAIN_SupportsCompressionType(TW_UINT16 comprType)	{		int rc;		TUINT32 size;		int found = FALSE;		TW_ENUMERATION *container = 0;		TW_HANDLE handle = 0;		if (!TTWAIN_IsCapCompressionSupported())			return FALSE;		rc = TTWAIN_GetCap(ICAP_COMPRESSION, TWON_ENUMERATION, (void *)0, &size);		if (!rc || !size)			return FALSE;		handle = GLOBAL_ALLOC(GMEM_FIXED, size);		if (!handle)			return FALSE;		container = (TW_ENUMERATION *)GLOBAL_LOCK(handle);		rc = TTWAIN_GetCap(ICAP_COMPRESSION, TWON_ENUMERATION, (void *)container, 0);		if (!rc)			goto done;		found = TTWAIN_IsItemInList(container->ItemList, &comprType,									container->NumItems, DCItemSize[container->ItemType]);		found = TRUE;	done:		if (handle) {			GLOBAL_UNLOCK(handle);			GLOBAL_FREE(handle);		}		return found;	}

	/*---------------------------------------------------------------------------*/	int TTWAIN_SupportsPixelType(TTWAIN_PIXTYPE pix_type)	{		TW_HANDLE handle;		TW_ENUMERATION *container;		int rc, found = FALSE;		TUINT32 size4data;		TW_UINT16 twPix;		twPix = PixType[pix_type].type;		rc = TTWAIN_GetCap(ICAP_PIXELTYPE, TWON_ENUMERATION, (void *)0, &size4data);		if (!rc)			return FALSE;		if (!size4data)			return FALSE;		handle = GLOBAL_ALLOC(GMEM_FIXED, size4data);		if (!handle)			return FALSE;		container = (TW_ENUMERATION *)GLOBAL_LOCK(handle);		rc = TTWAIN_GetCap(ICAP_PIXELTYPE, TWON_ENUMERATION, (void *)container, 0);		if (!rc)			goto done;		found = TTWAIN_IsItemInList(container->ItemList, &twPix,									container->NumItems, DCItemSize[container->ItemType]);	done:		GLOBAL_UNLOCK(handle);		GLOBAL_FREE(handle);		return found;	}

BOOL LPC24XX_TIMER_Driver::Initialize( UINT32 Timer, HAL_CALLBACK_FPN ISR, void* ISR_Param ){    ASSERT(Timer < c_MaxTimers);    GLOBAL_LOCK(irq);    if(g_LPC24XX_TIMER_Driver.m_configured[Timer] == TRUE) return FALSE;    //--//    if(ISR)    {        if(!CPU_INTC_ActivateInterrupt( LPC24XX_TIMER::getIntNo(Timer) , ISR, ISR_Param )) return FALSE;    }    LPC24XX_TIMER& TIMER = LPC24XX::TIMER( Timer );    TIMER.TCR = LPC24XX_TIMER::TCR_TEN;    //--//    g_LPC24XX_TIMER_Driver.m_configured[Timer] = TRUE;    return TRUE;}

BOOL Watchdog_LastOccurence( INT64& time, INT64& timeout, UINT32& assembly, UINT32& method, BOOL fSet ){    GLOBAL_LOCK(irq);    Watchdog_Driver::WatchdogEvent last;     if(fSet)    {        last.Time     = time;        last.Timeout  = timeout;        last.Assembly = assembly;        last.Method   = method;    }        BOOL fRes = Watchdog_Driver::LastOccurence( last, fSet );    if(!fSet && fRes)    {        time     = last.Time;        timeout  = last.Timeout;        assembly = last.Assembly;        method   = last.Method;    }    return fRes;}

void LPC24XX_USART_Driver::ProtectPins ( int ComPortNum, BOOL On ){    ASSERT(LPC24XX_USART_Driver::IsValidPortNum(ComPortNum));        static BOOL COM1_PinsProtected = TRUE;   // start out doing work on first unprotect    static BOOL COM2_PinsProtected = TRUE;   // start out doing work on first unprotect    static BOOL COM3_PinsProtected = TRUE;   // start out doing work on first unprotect    static BOOL COM4_PinsProtected = TRUE;   // start out doing work on first unprotect    GLOBAL_LOCK(irq);    UINT32                  SER_TXD;    UINT32                  SER_RXD;    BOOL*                   PinsProtected;    switch(ComPortNum)    {    case c_COM1: SER_TXD = LPC24XX_USART::c_SER1_TXD; SER_RXD = LPC24XX_USART::c_SER1_RXD; PinsProtected = &COM1_PinsProtected; break;    case c_COM2: SER_TXD = LPC24XX_USART::c_SER2_TXD; SER_RXD = LPC24XX_USART::c_SER2_RXD; PinsProtected = &COM2_PinsProtected; break;    case c_COM3: SER_TXD = LPC24XX_USART::c_SER3_TXD; SER_RXD = LPC24XX_USART::c_SER3_RXD; PinsProtected = &COM3_PinsProtected; break;    case c_COM4: SER_TXD = LPC24XX_USART::c_SER4_TXD; SER_RXD = LPC24XX_USART::c_SER4_RXD; PinsProtected = &COM4_PinsProtected; break;    default: return;    }    if (On)     {           if(!*PinsProtected)        {            *PinsProtected = TRUE;            TxBufferEmptyInterruptEnable( ComPortNum, FALSE );            // TODO Add config for uart pin protected state            CPU_GPIO_EnableOutputPin( SER_TXD, RESISTOR_DISABLED );            RxBufferFullInterruptEnable( ComPortNum, FALSE );            // TODO Add config for uart pin protected state            CPU_GPIO_EnableOutputPin( SER_RXD, RESISTOR_DISABLED );        }    }    else     {        if(*PinsProtected)        {            *PinsProtected = FALSE;            // Connect pin to UART            CPU_GPIO_DisablePin( SER_TXD, RESISTOR_DISABLED, GPIO_ATTRIBUTE_NONE, GPIO_ALT_MODE_1 );            // Connect pin to UART            CPU_GPIO_DisablePin( SER_RXD, RESISTOR_DISABLED, GPIO_ATTRIBUTE_NONE, GPIO_ALT_MODE_1 );            TxBufferEmptyInterruptEnable( ComPortNum, TRUE );            RxBufferFullInterruptEnable( ComPortNum, TRUE );        }    }    }

BOOL AT91_AIC_Driver::ActivateInterrupt(UINT32 Irq_Index, BOOL Fast, HAL_CALLBACK_FPN ISR, void* ISR_Param){    // figure out the interrupt    IRQ_VECTORING* IsrVector = IRQToIRQVector( Irq_Index );    if(!IsrVector)         return FALSE;    AT91_AIC &aic = AT91::AIC();    GLOBAL_LOCK(irq);    // disable this interrupt while we change it    aic.AIC_IDCR= (0x01 << Irq_Index);    // Clear the interrupt on the interrupt controller    aic.AIC_ICCR = (0x01 << Irq_Index);            // set the vector    IsrVector->Handler.Initialize( ISR, ISR_Param );    // enable the interrupt if we have a vector    aic.AIC_IECR= 0x01<<Irq_Index;    return TRUE;}

BOOL CPU_USART_Initialize( int ComPortNum, int BaudRate, int Parity, int DataBits, int StopBits, int FlowValue ){    if (ComPortNum >= TOTAL_USART_PORT)        return FALSE;    if (Parity >= USART_PARITY_MARK)        return FALSE;    GLOBAL_LOCK(irq);    ptr_USART_TypeDef uart = g_STM32F4_Uart_Ports[ComPortNum];    UINT32 clk;    // enable UART clock    if (ComPortNum == 5)    {   // COM6 on APB2        RCC->APB2ENR |= RCC_APB2ENR_USART6EN;        clk = SYSTEM_APB2_CLOCK_HZ;    }    else if (ComPortNum == 0)    {   // COM1 on APB2        RCC->APB2ENR |= RCC_APB2ENR_USART1EN;        clk = SYSTEM_APB2_CLOCK_HZ;    }    else if (ComPortNum < 5)    {   // COM2-5 on APB1        RCC->APB1ENR |= RCC_APB1ENR_USART2EN >> 1 << ComPortNum;        clk = SYSTEM_APB1_CLOCK_HZ;    }

// ---------------------------------------------------------------------------BOOL CPU_USB_ProtectPins(int core, BOOL On){    USB_CONTROLLER_STATE *State;    USBD_HANDLE_T hUsb = USB_HANDLE(core);    GLOBAL_LOCK(irq);    if (core >= MAX_USB_CORE) return FALSE;    State = USB_STATE(core);    if (On)    {        // Clear queues        for (int epNum = 1; epNum < State->EndpointCount; epNum++)        {            if (State->Queues[epNum] != NULL && State->IsTxQueue[epNum])                State->Queues[epNum]->Initialize();        }#if 0 // Don't disconnect on CDC        // Make soft disconnect and set detached state        USBD_Connect(hUsb, 0); // Disconnect        State->DeviceState = USB_DEVICE_STATE_DETACHED;        USB_StateCallback(State);#endif    } else {        // Make soft connect and set attached state        USBD_Connect(hUsb, 1); // Connect        State->DeviceState = USB_DEVICE_STATE_ATTACHED;        USB_StateCallback(State);    }    return TRUE;}

BOOL __section(SectionForFlashOperations) SAM7X_BS_Driver::ChipReadOnly(void * context, BOOL On, UINT32 ProtectionKey ){    // Internal setting for WriteProtection    AT91_BL_EFC &efc0 = AT91_BL_EFC::BL_EFC(0);    AT91_BL_EFC &efc1 = AT91_BL_EFC::BL_EFC(1);;    int i;    unsigned char command;     // Set Lock/Unlock command    command = (On == TRUE) ? AT91_BL_EFC::MC_FCMD_LOCK : AT91_BL_EFC::MC_FCMD_UNLOCK;    // Set EFC Mode Register - number of cycles during 1 microsecond    efc0.EFC_FMR = (efc0.EFC_FMR & ~AT91_BL_EFC::MC_FMCN) | ((SYSTEM_CYCLE_CLOCK_HZ / 1000000) << 16);    efc1.EFC_FMR = (efc1.EFC_FMR & ~AT91_BL_EFC::MC_FMCN) | ((SYSTEM_CYCLE_CLOCK_HZ / 1000000) << 16);    {        GLOBAL_LOCK(irq);        // Lock regions of EFC0 controller (1st FLASH block)        // Lock regions of EFC1 controller (2nd FLASH block)        for(i=0; i<16; i++ )        {            efc0.EFC_FCR = (AT91_BL_EFC::MC_KEY_VALUE | ((i*PAGES_IN_REGION) << 8) | command);            efc1.EFC_FCR = (AT91_BL_EFC::MC_KEY_VALUE | ((i*PAGES_IN_REGION) << 8) | command);            // Wait EFC ready             while(  ((efc0.EFC_FSR & AT91_BL_EFC::MC_FRDY) != AT91_BL_EFC::MC_FRDY)  &&                     ((efc1.EFC_FSR & AT91_BL_EFC::MC_FRDY) != AT91_BL_EFC::MC_FRDY)  );        }    }    return TRUE;}

BOOL LPC24XX_GPIO_Driver::Uninitialize(){    GLOBAL_LOCK(irq);    // uninitialize the interrupt information    {        PIN_ISR_DESCRIPTOR* pinIsr = g_LPC24XX_GPIO_Driver.m_PinIsr;        LPC24XX_GPIOIRQ& GPIOIRQ = LPC24XX::GPIOIRQ();        for(int i = 0; i < c_MaxPins; i++)        {            pinIsr->m_completion.Abort();            pinIsr++;        }        // turn off interrupts        GPIOIRQ.IO0IntEnR = 0x00000000;        GPIOIRQ.IO0IntEnF = 0x00000000;        GPIOIRQ.IO2IntEnR = 0x00000000;        GPIOIRQ.IO2IntEnF = 0x00000000;        // flush pending interrupts        GPIOIRQ.IO0IntClr = 0xFFFFFFFF;        GPIOIRQ.IO2IntClr = 0xFFFFFFFF;    }        if(!CPU_INTC_DeactivateInterrupt( LPC24XX_VIC::c_IRQ_INDEX_EINT3 )) return FALSE;        return TRUE;}

void LPC24XX_GPIO_Driver::EnableOutputPin( GPIO_PIN pin, BOOL initialState ){    ASSERT(pin < c_MaxPins);    UINT32 Port, Bit;        LPC24XX_GPIO& GPIO = LPC24XX::GPIO();    GLOBAL_LOCK(irq);//  hal_printf( "EnableOutputPin: %08x/r/n", pin);    Port = PinToPort(pin);    Bit = PinToBit(pin);    //  Set initial state before changing direction of the port pin    if(initialState) GPIO.Regs[Port].FIOSET_PX |=  (0x1 << Bit);    else             GPIO.Regs[Port].FIOCLR_PX |=  (0x1 << Bit);    GPIO.Regs[Port].FIODIR_PX |= 0x1 << Bit;        // Disable ISR    PIN_ISR_DESCRIPTOR& PinIsr = g_LPC24XX_GPIO_Driver.m_PinIsr[pin];    PinIsr.m_intEdge = GPIO_INT_NONE;    PinIsr.m_isr     = STUB_ISRVector;    PinIsr.m_param   = (void*)(size_t)pin;}

void SH7619_EDMAC_interrupt(void *param){	long eesr0_val;	GLOBAL_LOCK(encIrq);	Events_Set( SYSTEM_EVENT_FLAG_SOCKET );    		eesr0_val = EESR0;		if((eesr0_val & 0x00010000) == 0x00010000)	{				Flush_All(iface);		return;	}	// a Frame is transmitted	if((eesr0_val & 0x00200000) == 0x00200000)	{		//signal IP task that xmit has completed		rtp_net_invoke_output(iface, 1); 	}	// Frame(s) received	if((eesr0_val & 0x00040000) == 0x00040000)	{		rtp_thrd_interrupt_continuation(iface->ctrl.index);	}	ECSR0   = 0x00000007;	EESR0   = 0x47FF0F9F;}

/** Returns the number of nodes in this planning graph, including pnode.  */size_t infer_planner_node_num_dependency_nodes(std::shared_ptr<planner_node> pnode) {  std::lock_guard<recursive_mutex> GLOBAL_LOCK(global_query_lock);  std::set<pnode_ptr> seen_node_memo;  _fill_dependency_set(pnode, seen_node_memo);  return seen_node_memo.size();}