debug/org.eclipse.ptp.debug.core/pdi/org/eclipse/ptp/debug/internal/core/pdi/manager/MemoryManager.java - ptp/org.eclipse.ptp - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005 The Regents of the University of California.
  * This material was produced under U.S. Government contract W-7405-ENG-36
  * for Los Alamos National Laboratory, which is operated by the University
  * of California for the U.S. Department of Energy. The U.S. Government has
  * rights to use, reproduce, and distribute this software. NEITHER THE
  * GOVERNMENT NOR THE UNIVERSITY MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR
  * ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified
  * to produce derivative works, such modified software should be clearly marked,
  * so as not to confuse it with the version available from LANL.
  *
  * Additionally, this program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * LA-CC 04-115
  *******************************************************************************/
 package org.eclipse.ptp.debug.internal.core.pdi.manager;


 import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Hashtable;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.ptp.core.util.BitList;
 import org.eclipse.ptp.debug.core.ExtFormat;
 import org.eclipse.ptp.debug.core.pdi.IPDISession;
 import org.eclipse.ptp.debug.core.pdi.PDIException;
 import org.eclipse.ptp.debug.core.pdi.event.IPDIDataReadMemoryInfo;
 import org.eclipse.ptp.debug.core.pdi.event.IPDIEvent;
 import org.eclipse.ptp.debug.core.pdi.manager.IPDIMemoryManager;
 import org.eclipse.ptp.debug.core.pdi.model.IPDIMemoryBlock;
 import org.eclipse.ptp.debug.core.pdi.request.IPDIDataReadMemoryRequest;

 /**
  * @author Clement chu
  *
  */
 public class MemoryManager extends AbstractPDIManager implements IPDIMemoryManager {
 	IPDIMemoryBlock[] EMPTY_MEMORY_BLOCKS = {};
 	Map<BitList, List<IPDIMemoryBlock>> blockMap;

 	public MemoryManager(IPDISession session) {
 		super(session, true);
 		blockMap = new Hashtable<BitList, List<IPDIMemoryBlock>>();
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ptp.debug.core.pdi.manager.IPDIMemoryManager#createMemoryBlock(org.eclipse.ptp.core.util.BitList, java.lang.String, int, int)
 	 */
 	public IPDIMemoryBlock createMemoryBlock(BitList qTasks, String address, int units, int wordSize) throws PDIException {
 		IPDIDataReadMemoryInfo info = createDataReadMemoryInfo(qTasks, address, units, wordSize);
 		IPDIMemoryBlock block = session.getModelFactory().newMemoryBlock(session, qTasks, address, wordSize, true, info);
 		List<IPDIMemoryBlock> blockList = getMemoryBlockList(qTasks);
 		blockList.add(block);
 		IPDIEvent event = session.getEventFactory().newCreatedEvent(
 				session.getEventFactory().newMemoryBlockInfo(session, qTasks, new BigInteger[] { block.getStartAddress() }, block));
 		session.getEventManager().fireEvents(new IPDIEvent[] { event });
 		return block;
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ptp.debug.core.pdi.manager.IPDIMemoryManager#getMemoryBlocks(org.eclipse.ptp.core.util.BitList)
 	 */
 	public IPDIMemoryBlock[] getMemoryBlocks(BitList qTasks) throws PDIException {
 		List<IPDIMemoryBlock> blockList = getMemoryBlockList(qTasks);
 		return (IPDIMemoryBlock[]) blockList.toArray(new IPDIMemoryBlock[blockList.size()]);
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ptp.debug.core.pdi.manager.IPDIMemoryManager#removeAllBlocks(org.eclipse.ptp.core.util.BitList)
 	 */
 	public void removeAllBlocks(BitList qTasks) throws PDIException {
 		IPDIMemoryBlock[] blocks = getMemoryBlocks(qTasks);
 		removeBlocks(qTasks, blocks);
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ptp.debug.core.pdi.manager.IPDIMemoryManager#removeBlocks(org.eclipse.ptp.core.util.BitList, org.eclipse.ptp.debug.core.pdi.model.IPDIMemoryBlock[])
 	 */
 	public void removeBlocks(BitList qTasks, IPDIMemoryBlock[] memoryBlocks) throws PDIException {
 		List<IPDIMemoryBlock> blockList = blockMap.get(qTasks);
 		if (blockList != null) {
 			blockList.removeAll(Arrays.asList(memoryBlocks));
 		}
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ptp.debug.internal.core.pdi.AbstractPDIManager#shutdown()
 	 */
 	public void shutdown() {
 		blockMap.clear();
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ptp.debug.internal.core.pdi.AbstractPDIManager#update(org.eclipse.ptp.core.util.BitList)
 	 */
 	public void update(BitList qTasks) {
 		List<IPDIMemoryBlock> blockList = getMemoryBlockList(qTasks);
 		IPDIMemoryBlock[] blocks = (IPDIMemoryBlock[]) blockList.toArray(new IPDIMemoryBlock[blockList.size()]);
 		List<IPDIEvent> eventList = new ArrayList<IPDIEvent>(blocks.length);
 		for (int i = 0; i < blocks.length; i++) {
 			if (! blocks[i].isFrozen()) {
 				try {
 					update(blocks[i], eventList);
 				} catch (PDIException e) {
 				}
 			}
 		}
 		IPDIEvent[] events = (IPDIEvent[])eventList.toArray(new IPDIEvent[0]);
 		session.getEventManager().fireEvents(events);
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ptp.debug.core.pdi.manager.IPDIMemoryManager#update(org.eclipse.ptp.debug.core.pdi.model.IPDIMemoryBlock, java.util.List)
 	 */
 	public BigInteger[] update(IPDIMemoryBlock block, List<IPDIEvent> aList) throws PDIException {
 		IPDIMemoryBlock newBlock = cloneBlock(block);
 		boolean newAddress = ! newBlock.getStartAddress().equals(block.getStartAddress());
 		BigInteger[] array = compareBlocks(block, newBlock);
 		block.setDataReadMemoryInfo(newBlock.getDataReadMemoryInfo());
 		if (array.length > 0 || newAddress) {
 			IPDIEvent event = session.getEventFactory().newChangedEvent(
 					session.getEventFactory().newMemoryBlockInfo(session, block.getTasks(), array, block));
 			if (aList != null) {
 				aList.add(event);
 			} else {
 				session.getEventManager().fireEvents(new IPDIEvent[] { event });
 			}
 		}
 		return array;
 	}

 	/**
 	 * @param block
 	 * @return
 	 * @throws PDIException
 	 */
 	private IPDIMemoryBlock cloneBlock(IPDIMemoryBlock block) throws PDIException {
 		String exp = block.getExpression();
 		int wordSize = block.getWordSize();
 		IPDIDataReadMemoryInfo info = createDataReadMemoryInfo(block.getTasks(), exp, (int)block.getLength(), wordSize);
 		return session.getModelFactory().newMemoryBlock(session, block.getTasks(), exp, wordSize, true, info);
 	}

 	/**
 	 * @param oldBlock
 	 * @param newBlock
 	 * @return
 	 * @throws PDIException
 	 */
 	private BigInteger[] compareBlocks(IPDIMemoryBlock oldBlock, IPDIMemoryBlock newBlock) throws PDIException {
 		byte[] oldBytes = oldBlock.getBytes();
 		byte[] newBytes = newBlock.getBytes();
 		List<BigInteger> aList = new ArrayList<BigInteger>(newBytes.length);
 		BigInteger distance = newBlock.getStartAddress().subtract(oldBlock.getStartAddress());
 		int diff = distance.intValue();
 		if ( Math.abs(diff) <  newBytes.length) {
 			for (int i = 0; i < newBytes.length; i++) {
 				if (i + diff < oldBytes.length && i + diff >= 0) {
 					if (oldBytes[i + diff] != newBytes[i]) {
 						aList.add(newBlock.getStartAddress().add(BigInteger.valueOf(i)));
 					}
 				}
 			}
 		}
 		return (BigInteger[]) aList.toArray(new BigInteger[aList.size()]);
 	}

 	/**
 	 * @param qTasks
 	 * @param exp
 	 * @param units
 	 * @param wordSize
 	 * @return
 	 * @throws PDIException
 	 */
 	private IPDIDataReadMemoryInfo createDataReadMemoryInfo(BitList qTasks, String exp, int units, int wordSize) throws PDIException {
 		IPDIDataReadMemoryRequest request = session.getRequestFactory().getDataReadMemoryRequest(session, qTasks, 0, exp, ExtFormat.HEXADECIMAL, wordSize, 1, units, null);
 		session.getEventRequestManager().addEventRequest(request);
 		return request.getDataReadMemoryInfo(qTasks);
 	}

 	/**
 	 * @param qTasks
 	 * @return
 	 */
 	private synchronized List<IPDIMemoryBlock> getMemoryBlockList(BitList qTasks) {
 		List<IPDIMemoryBlock> blockList = blockMap.get(qTasks);
 		if (blockList == null) {
 			blockList = Collections.synchronizedList(new ArrayList<IPDIMemoryBlock>());
 			blockMap.put(qTasks, blockList);
 		}
 		return blockList;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005 The Regents of the University of California.
	* This material was produced under U.S. Government contract W-7405-ENG-36
	* for Los Alamos National Laboratory, which is operated by the University
	* of California for the U.S. Department of Energy. The U.S. Government has
	* rights to use, reproduce, and distribute this software. NEITHER THE
	* GOVERNMENT NOR THE UNIVERSITY MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR
	* ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified
	* to produce derivative works, such modified software should be clearly marked,
	* so as not to confuse it with the version available from LANL.
	*
	* Additionally, this program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* LA-CC 04-115
	*******************************************************************************/
	package org.eclipse.ptp.debug.internal.core.pdi.manager;


	import java.math.BigInteger;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.Hashtable;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.ptp.core.util.BitList;
	import org.eclipse.ptp.debug.core.ExtFormat;
	import org.eclipse.ptp.debug.core.pdi.IPDISession;
	import org.eclipse.ptp.debug.core.pdi.PDIException;
	import org.eclipse.ptp.debug.core.pdi.event.IPDIDataReadMemoryInfo;
	import org.eclipse.ptp.debug.core.pdi.event.IPDIEvent;
	import org.eclipse.ptp.debug.core.pdi.manager.IPDIMemoryManager;
	import org.eclipse.ptp.debug.core.pdi.model.IPDIMemoryBlock;
	import org.eclipse.ptp.debug.core.pdi.request.IPDIDataReadMemoryRequest;

	/**
	* @author Clement chu
	*
	*/
	public class MemoryManager extends AbstractPDIManager implements IPDIMemoryManager {
	IPDIMemoryBlock[] EMPTY_MEMORY_BLOCKS = {};
	Map<BitList, List<IPDIMemoryBlock>> blockMap;

	public MemoryManager(IPDISession session) {
	super(session, true);
	blockMap = new Hashtable<BitList, List<IPDIMemoryBlock>>();
	}

	/* (non-Javadoc)
	* @see org.eclipse.ptp.debug.core.pdi.manager.IPDIMemoryManager#createMemoryBlock(org.eclipse.ptp.core.util.BitList, java.lang.String, int, int)
	*/
	public IPDIMemoryBlock createMemoryBlock(BitList qTasks, String address, int units, int wordSize) throws PDIException {
	IPDIDataReadMemoryInfo info = createDataReadMemoryInfo(qTasks, address, units, wordSize);
	IPDIMemoryBlock block = session.getModelFactory().newMemoryBlock(session, qTasks, address, wordSize, true, info);
	List<IPDIMemoryBlock> blockList = getMemoryBlockList(qTasks);
	blockList.add(block);
	IPDIEvent event = session.getEventFactory().newCreatedEvent(
	session.getEventFactory().newMemoryBlockInfo(session, qTasks, new BigInteger[] { block.getStartAddress() }, block));
	session.getEventManager().fireEvents(new IPDIEvent[] { event });
	return block;
	}

	/* (non-Javadoc)
	* @see org.eclipse.ptp.debug.core.pdi.manager.IPDIMemoryManager#getMemoryBlocks(org.eclipse.ptp.core.util.BitList)
	*/
	public IPDIMemoryBlock[] getMemoryBlocks(BitList qTasks) throws PDIException {
	List<IPDIMemoryBlock> blockList = getMemoryBlockList(qTasks);
	return (IPDIMemoryBlock[]) blockList.toArray(new IPDIMemoryBlock[blockList.size()]);
	}

	/* (non-Javadoc)
	* @see org.eclipse.ptp.debug.core.pdi.manager.IPDIMemoryManager#removeAllBlocks(org.eclipse.ptp.core.util.BitList)
	*/
	public void removeAllBlocks(BitList qTasks) throws PDIException {
	IPDIMemoryBlock[] blocks = getMemoryBlocks(qTasks);
	removeBlocks(qTasks, blocks);
	}

	/* (non-Javadoc)
	* @see org.eclipse.ptp.debug.core.pdi.manager.IPDIMemoryManager#removeBlocks(org.eclipse.ptp.core.util.BitList, org.eclipse.ptp.debug.core.pdi.model.IPDIMemoryBlock[])
	*/
	public void removeBlocks(BitList qTasks, IPDIMemoryBlock[] memoryBlocks) throws PDIException {
	List<IPDIMemoryBlock> blockList = blockMap.get(qTasks);
	if (blockList != null) {
	blockList.removeAll(Arrays.asList(memoryBlocks));
	}
	}

	/* (non-Javadoc)
	* @see org.eclipse.ptp.debug.internal.core.pdi.AbstractPDIManager#shutdown()
	*/
	public void shutdown() {
	blockMap.clear();
	}

	/* (non-Javadoc)
	* @see org.eclipse.ptp.debug.internal.core.pdi.AbstractPDIManager#update(org.eclipse.ptp.core.util.BitList)
	*/
	public void update(BitList qTasks) {
	List<IPDIMemoryBlock> blockList = getMemoryBlockList(qTasks);
	IPDIMemoryBlock[] blocks = (IPDIMemoryBlock[]) blockList.toArray(new IPDIMemoryBlock[blockList.size()]);
	List<IPDIEvent> eventList = new ArrayList<IPDIEvent>(blocks.length);
	for (int i = 0; i < blocks.length; i++) {
	if (! blocks[i].isFrozen()) {
	try {
	update(blocks[i], eventList);
	} catch (PDIException e) {
	}
	}
	}
	IPDIEvent[] events = (IPDIEvent[])eventList.toArray(new IPDIEvent[0]);
	session.getEventManager().fireEvents(events);
	}

	/* (non-Javadoc)
	* @see org.eclipse.ptp.debug.core.pdi.manager.IPDIMemoryManager#update(org.eclipse.ptp.debug.core.pdi.model.IPDIMemoryBlock, java.util.List)
	*/
	public BigInteger[] update(IPDIMemoryBlock block, List<IPDIEvent> aList) throws PDIException {
	IPDIMemoryBlock newBlock = cloneBlock(block);
	boolean newAddress = ! newBlock.getStartAddress().equals(block.getStartAddress());
	BigInteger[] array = compareBlocks(block, newBlock);
	block.setDataReadMemoryInfo(newBlock.getDataReadMemoryInfo());
	if (array.length > 0 \|\| newAddress) {
	IPDIEvent event = session.getEventFactory().newChangedEvent(
	session.getEventFactory().newMemoryBlockInfo(session, block.getTasks(), array, block));
	if (aList != null) {
	aList.add(event);
	} else {
	session.getEventManager().fireEvents(new IPDIEvent[] { event });
	}
	}
	return array;
	}

	/**
	* @param block
	* @return
	* @throws PDIException
	*/
	private IPDIMemoryBlock cloneBlock(IPDIMemoryBlock block) throws PDIException {
	String exp = block.getExpression();
	int wordSize = block.getWordSize();
	IPDIDataReadMemoryInfo info = createDataReadMemoryInfo(block.getTasks(), exp, (int)block.getLength(), wordSize);
	return session.getModelFactory().newMemoryBlock(session, block.getTasks(), exp, wordSize, true, info);
	}

	/**
	* @param oldBlock
	* @param newBlock
	* @return
	* @throws PDIException
	*/
	private BigInteger[] compareBlocks(IPDIMemoryBlock oldBlock, IPDIMemoryBlock newBlock) throws PDIException {
	byte[] oldBytes = oldBlock.getBytes();
	byte[] newBytes = newBlock.getBytes();
	List<BigInteger> aList = new ArrayList<BigInteger>(newBytes.length);
	BigInteger distance = newBlock.getStartAddress().subtract(oldBlock.getStartAddress());
	int diff = distance.intValue();
	if ( Math.abs(diff) < newBytes.length) {
	for (int i = 0; i < newBytes.length; i++) {
	if (i + diff < oldBytes.length && i + diff >= 0) {
	if (oldBytes[i + diff] != newBytes[i]) {
	aList.add(newBlock.getStartAddress().add(BigInteger.valueOf(i)));
	}
	}
	}
	}
	return (BigInteger[]) aList.toArray(new BigInteger[aList.size()]);
	}

	/**
	* @param qTasks
	* @param exp
	* @param units
	* @param wordSize
	* @return
	* @throws PDIException
	*/
	private IPDIDataReadMemoryInfo createDataReadMemoryInfo(BitList qTasks, String exp, int units, int wordSize) throws PDIException {
	IPDIDataReadMemoryRequest request = session.getRequestFactory().getDataReadMemoryRequest(session, qTasks, 0, exp, ExtFormat.HEXADECIMAL, wordSize, 1, units, null);
	session.getEventRequestManager().addEventRequest(request);
	return request.getDataReadMemoryInfo(qTasks);
	}

	/**
	* @param qTasks
	* @return
	*/
	private synchronized List<IPDIMemoryBlock> getMemoryBlockList(BitList qTasks) {
	List<IPDIMemoryBlock> blockList = blockMap.get(qTasks);
	if (blockList == null) {
	blockList = Collections.synchronizedList(new ArrayList<IPDIMemoryBlock>());
	blockMap.put(qTasks, blockList);
	}
	return blockList;
	}
	}