Package org.jgroups.protocols

Class TP

    • Field Detail

      • MIN_WAIT_BETWEEN_DISCOVERIES

        protected static final long MIN_WAIT_BETWEEN_DISCOVERIES

      • bind_addr

        protected java.net.InetAddress bind_addr

      • use_ip_addrs

        protected boolean use_ip_addrs

      • external_addr

        protected java.net.InetAddress external_addr

      • external_port

        protected int external_port

      • is_trace

        protected boolean is_trace

      • receive_on_all_interfaces

        protected boolean receive_on_all_interfaces

      • receive_interfaces

        protected java.util.List<java.net.NetworkInterface> receive_interfaces
        List of interfaces to receive multicasts on. The multicast receive socket will listen on all of these interfaces. This is a comma-separated list of IP addresses or interface names. E.g. "192.168.5.1,eth1,127.0.0.1". Duplicates are discarded; we only bind to an interface once. If this property is set, it overrides receive_on_all_interfaces.

      • logical_addr_cache_max_size

        protected int logical_addr_cache_max_size

      • logical_addr_cache_expiration

        protected long logical_addr_cache_expiration

      • logical_addr_cache_reaper_interval

        protected long logical_addr_cache_reaper_interval

      • bind_port

        protected int bind_port
        The port to which the transport binds. 0 means to bind to any (ephemeral) port. See also port_range

      • port_range

        protected int port_range

      • loopback_copy

        protected boolean loopback_copy

      • loopback_separate_thread

        protected boolean loopback_separate_thread

      • message_processing_policy

        protected java.lang.String message_processing_policy

      • msg_processing_max_buffer_size

        protected int msg_processing_max_buffer_size

      • thread_naming_pattern

        protected java.lang.String thread_naming_pattern

      • use_fork_join_pool

        protected boolean use_fork_join_pool

      • use_common_fork_join_pool

        protected boolean use_common_fork_join_pool

      • use_fibers

        protected boolean use_fibers

      • thread_pool_enabled

        protected boolean thread_pool_enabled

      • thread_pool_min_threads

        protected int thread_pool_min_threads

      • thread_pool_max_threads

        protected int thread_pool_max_threads

      • thread_pool_keep_alive_time

        protected long thread_pool_keep_alive_time

      • spawn_thread_on_full_pool

        protected boolean spawn_thread_on_full_pool

      • time_service_interval

        protected long time_service_interval

      • enable_diagnostics

        protected boolean enable_diagnostics

      • diag_enable_udp

        protected boolean diag_enable_udp

      • diag_enable_tcp

        protected boolean diag_enable_tcp

      • diagnostics_addr

        protected java.net.InetAddress diagnostics_addr

      • diagnostics_bind_addr

        protected java.net.InetAddress diagnostics_bind_addr

      • diagnostics_bind_interfaces

        protected java.util.List<java.net.NetworkInterface> diagnostics_bind_interfaces

      • diagnostics_port

        protected int diagnostics_port

      • diagnostics_port_range

        protected int diagnostics_port_range

      • diagnostics_ttl

        protected int diagnostics_ttl

      • diagnostics_passcode

        protected java.lang.String diagnostics_passcode

      • log_discard_msgs

        protected boolean log_discard_msgs
        Whether or not warnings about messages from different groups are logged - private flag, not for common use

      • log_discard_msgs_version

        protected boolean log_discard_msgs_version

      • who_has_cache_timeout

        protected long who_has_cache_timeout

      • suppress_time_different_version_warnings

        protected long suppress_time_different_version_warnings

      • suppress_time_different_cluster_warnings

        protected long suppress_time_different_cluster_warnings

      • thread_dumps_threshold

        protected int thread_dumps_threshold

      • thread_dump_path

        protected java.lang.String thread_dump_path

      • thread_dumps

        protected final java.util.concurrent.atomic.AtomicInteger thread_dumps

      • max_bundle_size

        protected int max_bundle_size
        Maximum number of bytes for messages to be queued until they are sent. This value needs to be smaller than the largest datagram packet size in case of UDP

      • bundler_type

        protected java.lang.String bundler_type

      • drop_when_full

        protected boolean drop_when_full

      • bundler_capacity

        protected int bundler_capacity

      • bundler_num_spins

        protected int bundler_num_spins

      • bundler_wait_strategy

        protected java.lang.String bundler_wait_strategy

      • msg_stats

        protected final MsgStats msg_stats

      • cluster_name

        protected AsciiString cluster_name
        The name of the group to which this member is connected. With a shared transport, the channel name is in TP.ProtocolAdapter (cluster_name), and this field is not used

      • timer_handle_non_blocking_tasks

        protected boolean timer_handle_non_blocking_tasks

      • local_addr

        protected Address local_addr
        The address (host and port) of this member

      • view

        protected volatile View view

      • members

        protected final java.util.Set<Address> members
        The members of this group (updated when a member joins or leaves). With a shared transport, members contains *all* members from all channels sitting on the shared transport

      • connectLock

        protected final java.util.concurrent.locks.ReentrantLock connectLock

      • thread_pool

        protected java.util.concurrent.Executor thread_pool
        The thread pool which handles unmarshalling, version checks and dispatching of messages

      • thread_factory

        protected ThreadFactory thread_factory
        Factory which is used by the thread pool

      • internal_thread_factory

        protected ThreadFactory internal_thread_factory

      • internal_pool

        protected java.util.concurrent.Executor internal_pool

      • bundler

        protected Bundler bundler

      • header

        protected TpHeader header
        The header including the cluster name, sent with each message. Not used with a shared transport (instead TP.ProtocolAdapter attaches the header to the message

      • logical_addr_cache

        protected LazyRemovalCache<Address,​PhysicalAddress> logical_addr_cache
        Cache which maintains mappings between logical and physical addresses. When sending a message to a logical address, we look up the physical address from logical_addr_cache and send the message to the physical address
        The keys are logical addresses, the values physical addresses

      • last_discovery_request

        protected long last_discovery_request

      • logical_addr_cache_reaper

        protected java.util.concurrent.Future<?> logical_addr_cache_reaper

      • who_has_cache

        protected ExpiryCache<Address> who_has_cache
        Cache keeping track of WHO_HAS requests for physical addresses (given a logical address) and expiring them after who_has_cache_timeout ms

      • suppress_log_different_version

        protected SuppressLog<Address> suppress_log_different_version
        Log to suppress identical warnings for messages from members with different (incompatible) versions

      • suppress_log_different_cluster

        protected SuppressLog<Address> suppress_log_different_cluster
        Log to suppress identical warnings for messages from members in different clusters

    • Constructor Detail

      • TP

        protected TP()
        Creates the TP protocol, and initializes the state variables, does however not start any sockets or threads.

    • Method Detail

      • getBundlerClass

        public java.lang.String getBundlerClass()

      • setMaxBundleSize

        public <T extends TP> T setMaxBundleSize​(int size)

      • getMaxBundleSize

        public final int getMaxBundleSize()

      • getBundlerCapacity

        public int getBundlerCapacity()

      • setBundlerCapacity

        public <T extends TP> T setBundlerCapacity​(int c)

      • getMessageProcessingMaxBufferSize

        public int getMessageProcessingMaxBufferSize()

      • useFibers

        public boolean useFibers()

      • getThreadDumpsThreshold

        public int getThreadDumpsThreshold()

      • setThreadDumpsThreshold

        public <T extends TP> T setThreadDumpsThreshold​(int t)

      • getDropWhenFull

        public boolean getDropWhenFull()

      • setDropWhenFull

        public <T extends TP> T setDropWhenFull​(boolean b)

      • getBundlerBufferSize

        public int getBundlerBufferSize()

      • bundlerWaitStrategy

        public java.lang.String bundlerWaitStrategy()

      • bundlerWaitStrategy

        public <T extends TP> T bundlerWaitStrategy​(java.lang.String strategy)

      • bundlerNumSpins

        public int bundlerNumSpins()

      • bundlerNumSpins

        public <T extends TP> T bundlerNumSpins​(int spins)

      • isLogicalAddressCacheReaperRunning

        public boolean isLogicalAddressCacheReaperRunning()

      • getAvgBatchSize

        public java.lang.String getAvgBatchSize()

      • setThreadPoolMinThreads

        public <T extends TP> T setThreadPoolMinThreads​(int size)

      • getThreadPoolMinThreads

        public int getThreadPoolMinThreads()

      • setThreadPoolMaxThreads

        public <T extends TP> T setThreadPoolMaxThreads​(int size)

      • getThreadPoolMaxThreads

        public int getThreadPoolMaxThreads()

      • setThreadPoolKeepAliveTime

        public <T extends TP> T setThreadPoolKeepAliveTime​(long time)

      • getThreadPoolKeepAliveTime

        public long getThreadPoolKeepAliveTime()

      • setLevel

        public <T extends Protocol> T setLevel​(java.lang.String level)
        Description copied from class: Protocol
        Sets the level of a logger. This method is used to dynamically change the logging level of a running system, e.g. via JMX. The appender of a level needs to exist.
        Overrides:
        setLevel in class Protocol
        Parameters:
        level - The new level. Valid values are "fatal", "error", "warn", "info", "debug", "trace" (capitalization not relevant)

      • getNumberOfThreadDumps

        public int getNumberOfThreadDumps()

      • resetThreadDumps

        public void resetThreadDumps()

      • setMessageProcessingPolicy

        public void setMessageProcessingPolicy​(java.lang.String policy)

      • getTimerClass

        public java.lang.String getTimerClass()

      • getClusterName

        public java.lang.String getClusterName()

      • getClusterNameAscii

        public AsciiString getClusterNameAscii()

      • getDifferentClusterMessages

        public int getDifferentClusterMessages()

      • getDifferentVersionMessages

        public int getDifferentVersionMessages()

      • clearDifferentClusterCache

        public <T extends TP> T clearDifferentClusterCache()

      • clearDifferentVersionCache

        public <T extends TP> T clearDifferentVersionCache()

      • loggerType

        public static java.lang.String loggerType()

      • enableBlockingTimerTasks

        public <T extends TP> T enableBlockingTimerTasks​(boolean flag)

      • getMessageStats

        public MsgStats getMessageStats()

      • supportsMulticasting

        public abstract boolean supportsMulticasting()
        Whether or not hardware multicasting is supported

      • isMulticastCapable

        public boolean isMulticastCapable()

      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object

      • getLocalAddress

        public java.lang.String getLocalAddress()

      • localAddress

        public Address localAddress()

      • view

        public View view()

      • getLocalPhysicalAddress

        public java.lang.String getLocalPhysicalAddress()

      • setDiagnosticsHandler

        public <T extends TP> T setDiagnosticsHandler​(DiagnosticsHandler handler)
                                       throws java.lang.Exception
        Sets a DiagnosticsHandler. Should be set before the stack is started
        Parameters:
        handler -
        Throws:
        java.lang.Exception

      • getBundler

        public Bundler getBundler()

      • setBundler

        public <T extends TP> T setBundler​(Bundler bundler)
        Installs a bundler. Needs to be done before the channel is connected

      • getThreadPool

        public java.util.concurrent.Executor getThreadPool()

      • setThreadPool

        public <T extends TP> T setThreadPool​(java.util.concurrent.Executor thread_pool)

      • getThreadPoolThreadFactory

        public ThreadFactory getThreadPoolThreadFactory()

      • setThreadPoolThreadFactory

        public <T extends TP> T setThreadPoolThreadFactory​(ThreadFactory factory)

      • getInternalThreadPool

        public java.util.concurrent.Executor getInternalThreadPool()

      • setInternalThreadPool

        public <T extends TP> T setInternalThreadPool​(java.util.concurrent.Executor thread_pool)

      • getInternalThreadPoolThreadFactory

        public ThreadFactory getInternalThreadPoolThreadFactory()

      • setInternalThreadPoolThreadFactory

        public <T extends TP> T setInternalThreadPoolThreadFactory​(ThreadFactory factory)

      • setTimer

        public <T extends TP> T setTimer​(TimeScheduler timer)
        Sets a new timer. This should be done before the transport is initialized; be very careful, as replacing a running timer with tasks in it can wreak havoc !
        Parameters:
        timer -

      • setTimeService

        public <T extends TP> T setTimeService​(TimeService ts)

      • getThreadFactory

        public ThreadFactory getThreadFactory()
        Description copied from class: Protocol
        Supposed to be overwritten by subclasses. Usually the transport returns a valid non-null thread factory, but thread factories can also be created by individual protocols
        Overrides:
        getThreadFactory in class Protocol
        Returns:

      • setThreadFactory

        public <T extends TP> T setThreadFactory​(ThreadFactory factory)

      • getSocketFactory

        public SocketFactory getSocketFactory()
        Description copied from class: Protocol
        Returns the SocketFactory associated with this protocol, if overridden in a subclass, or passes the call down
        Overrides:
        getSocketFactory in class Protocol
        Returns:
        SocketFactory

      • setSocketFactory

        public void setSocketFactory​(SocketFactory factory)
        Description copied from class: Protocol
        Sets a SocketFactory. Socket factories are typically provided by the transport (TP)
        Overrides:
        setSocketFactory in class Protocol

      • getThreadNamingPattern

        public java.lang.String getThreadNamingPattern()
        Names the current thread. Valid values are "pcl": p: include the previous (original) name, e.g. "Incoming thread-1", "UDP ucast receiver" c: include the cluster name, e.g. "MyCluster" l: include the local address of the current member, e.g. "192.168.5.1:5678"

      • getNumMessagesSent

        public long getNumMessagesSent()

      • incrBatchesSent

        public <T extends TP> T incrBatchesSent​(int delta)

      • incrNumSingleMsgsSent

        public <T extends TP> T incrNumSingleMsgsSent​(int d)

      • getBindAddress

        public java.net.InetAddress getBindAddress()

      • setBindAddress

        public <T extends TP> T setBindAddress​(java.net.InetAddress a)

      • getBindPort

        public int getBindPort()

      • setBindPort

        public <T extends TP> T setBindPort​(int port)

      • setBindToAllInterfaces

        public <T extends TP> T setBindToAllInterfaces​(boolean f)

      • isReceiveOnAllInterfaces

        public boolean isReceiveOnAllInterfaces()

      • getReceiveInterfaces

        public java.util.List<java.net.NetworkInterface> getReceiveInterfaces()

      • setPortRange

        public <T extends TP> T setPortRange​(int range)

      • getPortRange

        public int getPortRange()

      • getThreadPoolSize

        public int getThreadPoolSize()

      • getThreadPoolSizeActive

        public int getThreadPoolSizeActive()

      • getThreadPoolSizeLargest

        public int getThreadPoolSizeLargest()

      • getInternalThreadPoolSize

        public int getInternalThreadPoolSize()

      • getInternalThreadPoolSizeLargest

        public int getInternalThreadPoolSizeLargest()

      • getNumTimerTasks

        public int getNumTimerTasks()

      • dumpTimerTasks

        public java.lang.String dumpTimerTasks()

      • removeCancelledTimerTasks

        public void removeCancelledTimerTasks()

      • getTimerThreads

        public int getTimerThreads()

      • getNumThreads

        public static int getNumThreads()

      • isDiagnosticsRunning

        public boolean isDiagnosticsRunning()

      • setLogDiscardMessages

        public <T extends TP> T setLogDiscardMessages​(boolean flag)

      • getLogDiscardMessages

        public boolean getLogDiscardMessages()

      • setLogDiscardMessagesVersion

        public <T extends TP> T setLogDiscardMessagesVersion​(boolean f)

      • getLogDiscardMessagesVersion

        public boolean getLogDiscardMessagesVersion()

      • getUseIpAddresses

        public boolean getUseIpAddresses()

      • isDiagnosticsEnabled

        public boolean isDiagnosticsEnabled()

      • setDiagnosticsEnabled

        public <T extends TP> T setDiagnosticsEnabled​(boolean f)

      • isDiagUdEnabled

        public boolean isDiagUdEnabled()

      • diagEnableUdp

        public <T extends TP> T diagEnableUdp​(boolean f)

      • diagTcpEnabled

        public boolean diagTcpEnabled()

      • diagEnableTcp

        public <T extends TP> T diagEnableTcp​(boolean f)

      • printLogicalAddressCache

        public java.lang.String printLogicalAddressCache()

      • printWhoHasCache

        public java.lang.String printWhoHasCache()

      • evictLogicalAddressCache

        public void evictLogicalAddressCache()

      • evictLogicalAddressCache

        public void evictLogicalAddressCache​(boolean force)

      • sendMulticast

        public abstract void sendMulticast​(byte[] data,
                                   int offset,
                                   int length)
                            throws java.lang.Exception
        Send to all members in the group. UDP would use an IP multicast message, whereas TCP would send N messages, one for each member
        Parameters:
        data - The data to be sent. This is not a copy, so don't modify it
        offset -
        length -
        Throws:
        java.lang.Exception

      • sendUnicast

        public abstract void sendUnicast​(PhysicalAddress dest,
                                 byte[] data,
                                 int offset,
                                 int length)
                          throws java.lang.Exception
        Send a unicast to 1 member. Note that the destination address is a *physical*, not a logical address
        Parameters:
        dest - Must be a non-null unicast address
        data - The data to be sent. This is not a copy, so don't modify it
        offset -
        length -
        Throws:
        java.lang.Exception

      • getInfo

        public abstract java.lang.String getInfo()

      • init

        public void init()
          throws java.lang.Exception
        Description copied from class: Protocol
        Called after instance has been created (null constructor) and before protocol is started. Properties are already set. Other protocols are not yet connected and events cannot yet be sent.
        Overrides:
        init in class Protocol
        Throws:
        java.lang.Exception - Thrown if protocol cannot be initialized successfully. This will cause the ProtocolStack to fail, so the channel constructor will throw an exception

      • start

        public void start()
           throws java.lang.Exception
        Creates the unicast and multicast sockets and starts the unicast and multicast receiver threads
        Overrides:
        start in class Protocol
        Throws:
        java.lang.Exception - Thrown if protocol cannot be started successfully. This will cause the ProtocolStack to fail, so JChannel.connect(String) will throw an exception

      • stop

        public void stop()
        Description copied from class: Protocol
        This method is called on a JChannel.disconnect(). Stops work (e.g. by closing multicast socket). Will be called from top to bottom. This means that at the time of the method invocation the neighbor protocol below is still working. This method will replace the STOP, STOP_OK, CLEANUP and CLEANUP_OK events. The ProtocolStack guarantees that when this method is called all messages in the down queue will have been flushed
        Overrides:
        stop in class Protocol

      • destroy

        public void destroy()
        Description copied from class: Protocol
        This method is called on a JChannel.close(). Does some cleanup; after the call the VM will terminate
        Overrides:
        destroy in class Protocol

      • bundlerStats

        public java.lang.String bundlerStats()

      • bundlerStatsReset

        public void bundlerStatsReset()

      • bundler

        public <T extends TP> T bundler​(java.lang.String type)

      • enableDiagnostics

        public void enableDiagnostics()

      • disableDiagnostics

        public void disableDiagnostics()

      • startDiagnostics

        protected void startDiagnostics()
                         throws java.lang.Exception
        Throws:
        java.lang.Exception

      • stopDiagnostics

        protected void stopDiagnostics()

      • handleProbe

        public java.util.Map<java.lang.String,​java.lang.String> handleProbe​(java.lang.String... keys)
        Description copied from interface: DiagnosticsHandler.ProbeHandler
        Handles a probe. For each key that is handled, the key and its result should be in the returned map.
        Specified by:
        handleProbe in interface DiagnosticsHandler.ProbeHandler
        Returns:
        Map. A map of keys and values. A null return value is permissible.

      • handleConnect

        protected void handleConnect()
                      throws java.lang.Exception
        Throws:
        java.lang.Exception

      • handleDisconnect

        protected void handleDisconnect()

      • down

        public java.lang.Object down​(Event evt)
        Description copied from class: Protocol
        An event is to be sent down the stack. A protocol may want to examine its type and perform some action on it, depending on the event's type. If the event is a message MSG, then the protocol may need to add a header to it (or do nothing at all) before sending it down the stack using down_prot.down().
        Overrides:
        down in class Protocol

      • down

        public java.lang.Object down​(Message msg)
        A message needs to be sent to a single member or all members
        Overrides:
        down in class Protocol

      • createBundler

        protected Bundler createBundler​(java.lang.String type)

      • loopback

        protected void loopback​(Message msg,
                        boolean multicast)

      • setSourceAddress

        protected void setSourceAddress​(Message msg)
        If the sender is null, set our own address. We cannot just go ahead and set the address anyway, as we might be sending a message on behalf of someone else ! E.g. in case of retransmission, when the original sender has crashed, or in a FLUSH protocol when we have to return all unstable messages with the FLUSH_OK response.

      • passMessageUp

        public void passMessageUp​(Message msg,
                          byte[] cluster_name,
                          boolean perform_cluster_name_matching,
                          boolean multicast,
                          boolean discard_own_mcast)

      • passBatchUp

        public void passBatchUp​(MessageBatch batch,
                        boolean perform_cluster_name_matching,
                        boolean discard_own_mcast)

      • receive

        public void receive​(Address sender,
                    byte[] data,
                    int offset,
                    int length)
        Subclasses must call this method when a unicast or multicast message has been received.

      • receive

        public void receive​(Address sender,
                    java.io.DataInput in)
             throws java.lang.Exception
        Throws:
        java.lang.Exception

      • handleMessageBatch

        protected void handleMessageBatch​(java.io.DataInput in,
                                  boolean multicast)

      • handleSingleMessage

        protected void handleSingleMessage​(java.io.DataInput in,
                                   boolean multicast)

      • processBatch

        protected void processBatch​(MessageBatch batch,
                            boolean oob,
                            boolean internal)

      • unicastDestMismatch

        public boolean unicastDestMismatch​(Address dest)

      • submitToThreadPool

        public boolean submitToThreadPool​(java.lang.Runnable task,
                                  boolean spawn_thread_on_rejection)

      • submitToThreadPool

        public boolean submitToThreadPool​(java.util.concurrent.Executor pool,
                                  java.lang.Runnable task,
                                  boolean spawn_thread_on_rejection,
                                  boolean forward_to_internal_pool)

      • runInNewThread

        protected boolean runInNewThread​(java.lang.Runnable task)

      • versionMatch

        protected boolean versionMatch​(short version,
                               Address sender)

      • send

        protected void send​(Message msg)
             throws java.lang.Exception
        Serializes and sends a message. This method is not reentrant
        Throws:
        java.lang.Exception

      • doSend

        public void doSend​(byte[] buf,
                   int offset,
                   int length,
                   Address dest)
            throws java.lang.Exception
        Throws:
        java.lang.Exception

      • sendToSingleMember

        protected void sendToSingleMember​(Address dest,
                                  byte[] buf,
                                  int offset,
                                  int length)
                           throws java.lang.Exception
        Throws:
        java.lang.Exception

      • sendToMembers

        protected void sendToMembers​(java.util.Collection<Address> mbrs,
                             byte[] buf,
                             int offset,
                             int length)
                      throws java.lang.Exception
        Fetches the physical addrs for mbrs and sends the msg to each physical address. Asks discovery for missing members' physical addresses if needed
        Throws:
        java.lang.Exception

      • fetchPhysicalAddrs

        protected void fetchPhysicalAddrs​(java.util.List<Address> missing)

      • fetchResponsesFromDiscoveryProtocol

        protected Responses fetchResponsesFromDiscoveryProtocol​(java.util.List<Address> missing)

      • timestamp

        protected long timestamp()

      • registerLocalAddress

        protected void registerLocalAddress​(Address addr)
        Associates the address with the physical address fetched from the cache
        Parameters:
        addr -

      • fetchLocalAddresses

        protected void fetchLocalAddresses()
        Grabs the local address (or addresses in the shared transport case) and registers them with the physical address in the transport's cache

      • setThreadNames

        protected void setThreadNames()

      • unsetThreadNames

        protected void unsetThreadNames()

      • setInAllThreadFactories

        protected void setInAllThreadFactories​(java.lang.String cluster_name,
                                       Address local_address,
                                       java.lang.String pattern)

      • createThreadPool

        protected static java.util.concurrent.ExecutorService createThreadPool​(int min_threads,
                                                                       int max_threads,
                                                                       long keep_alive_time,
                                                                       java.lang.String rejection_policy,
                                                                       java.util.concurrent.BlockingQueue<java.lang.Runnable> queue,
                                                                       ThreadFactory factory,
                                                                       Log log,
                                                                       boolean use_fork_join_pool,
                                                                       boolean use_common_fork_join_pool)

      • shutdownThreadPool

        protected static void shutdownThreadPool​(java.util.concurrent.Executor thread_pool)

      • addPhysicalAddressToCache

        protected boolean addPhysicalAddressToCache​(Address logical_addr,
                                            PhysicalAddress physical_addr)

      • addPhysicalAddressToCache

        protected boolean addPhysicalAddressToCache​(Address logical_addr,
                                            PhysicalAddress physical_addr,
                                            boolean overwrite)

      • getPhysicalAddressFromCache

        protected PhysicalAddress getPhysicalAddressFromCache​(Address logical_addr)

      • getAllPhysicalAddressesFromCache

        protected java.util.Collection<PhysicalAddress> getAllPhysicalAddressesFromCache()

      • removeLogicalAddressFromCache

        protected void removeLogicalAddressFromCache​(Address logical_addr)

      • clearLogicalAddressCache

        public void clearLogicalAddressCache()
        Clears the cache. Do not use, this is only for unit testing !

      • getPhysicalAddress

        protected abstract PhysicalAddress getPhysicalAddress()