PureEdgeSim -datacentermanager包-ComputingNodesGenerator文件

最新推荐文章于 2024-06-09 09:48:54 发布
最新推荐文章于 2024-06-09 09:48:54 发布
阅读量330 收藏
点赞数 9
分类专栏： PureEdgeSim 文章标签： 云计算 边缘计算 笔记 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ADEXOM/article/details/134394124
版权

ComputingNodesGenerator

用来生成计算资源

获得所有的资源编排器

	/**
	 * The list that contains all orchestrators. It is used by the computing node.
	 * In this case, the tasks are sent over the network to one of the orchestrators
	 * to make decisions.
	 * 
	 * @see #generateDataCenters(String, TYPES)
	 * @see com.mechalikh.pureedgesim.simulationmanager.DefaultSimulationManager#sendTaskToOrchestrator(Task)
	 */
	//获得所有的编排器
	protected List<ComputingNode> orchestratorsList;

仿真管理

	/**
	 * The simulation manager.
	 */
	protected SimulationManager simulationManager;

场景的移动模型

	/**
	 * The Mobility Model to be used in this scenario
	 * 
	 * @see com.mechalikh.pureedgesim.simulationmanager.SimulationThread#loadModels(DefaultSimulationManager)
	 */
	protected Class<? extends MobilityModel> mobilityModelClass;

场景的计算节点

	/**
	 * The Computing Node Class to be used in this scenario
	 * 
	 * @see com.mechalikh.pureedgesim.simulationmanager.SimulationThread#loadModels(DefaultSimulationManager)
	 */
	protected Class<? extends ComputingNode> computingNodeClass;

边缘设备列表

	/**
	 * A list that contains all edge devices including sensors (i.e., devices
	 * without computing capacities).
	 * 
	 * @see com.mechalikh.pureedgesim.taskorchestrator.Orchestrator#mistOnly(Task
	 *      task)
	 */
	protected List<ComputingNode> mistOnlyList;

有计算能力的边缘设备

	/**
	 * A list that contains all edge devices except sensors (i.e., devices without
	 * computing capacities).
	 * 
	 * @see com.mechalikh.pureedgesim.taskorchestrator.Orchestrator#mistOnly(Task
	 *      task)
	 */
	protected List<ComputingNode> mistOnlyListSensorsExcluded;

包含边缘计算中心的列表

	/**
	 * A list that contains only edge data centers and servers.
	 * 
	 * @see com.mechalikh.pureedgesim.taskorchestrator.Orchestrator#edgeOnly(Task
	 *      task)
	 */
	protected List<ComputingNode> edgeOnlyList = new ArrayList<>(SimulationParameters.numberOfEdgeDataCenters);

包含所有云计算中心的列表

	/**
	 * A list that contains only cloud data centers.
	 * 
	 * @see com.mechalikh.pureedgesim.taskorchestrator.Orchestrator#cloudOnly(Task
	 *      task)
	 */
	protected List<ComputingNode> cloudOnlyList = new ArrayList<>(SimulationParameters.numberOfCloudDataCenters);

云数据中心和边缘设备(有计算能力)列表

	/**
	 * A list that contains cloud data centers and edge devices (except sensors).
	 * 
	 * @see com.mechalikh.pureedgesim.taskorchestrator.Orchestrator#mistAndCloud(Task
	 *      task)
	 */
	protected List<ComputingNode> mistAndCloudListSensorsExcluded;

包含所有云数据中心和边缘数据中的列表

	/**
	 * A list that contains cloud and edge data centers.
	 * 
	 * @see com.mechalikh.pureedgesim.taskorchestrator.Orchestrator#edgeAndCloud(Task
	 *      task)
	 */
	protected List<ComputingNode> edgeAndCloudList = new ArrayList<>(
			SimulationParameters.numberOfCloudDataCenters + SimulationParameters.numberOfEdgeDataCenters);

包括边缘数据中心和边缘设备(不包括无计算能力)

	/**
	 * A list that contains edge data centers and edge devices (except sensors).
	 * 
	 * @see com.mechalikh.pureedgesim.taskorchestrator.Orchestrator#mistAndEdge(Task
	 *      task)
	 */
	protected List<ComputingNode> mistAndEdgeListSensorsExcluded;

包括传感器的所有设备列表

	/**
	 * A list that contains all generated nodes including sensors
	 * 
	 * @see com.mechalikh.pureedgesim.taskorchestrator.Orchestrator#all(Task task)
	 */
	protected List<ComputingNode> allNodesList;

不包括无计算能力边缘设备的列表

	/**
	 * A list that contains all generated nodes (sensors excluded)
	 * 
	 * @see com.mechalikh.pureedgesim.taskorchestrator.Orchestrator#all(Task task)
	 */
	protected List<ComputingNode> allNodesListSensorsExcluded;

构造函数

	/**
	 * Constructs a new instance of the computing nodes generator.
	 * 
	 * @param simulationManager  The simulation manager to use.
	 * @param mobilityModelClass The mobility model to use.
	 * @param computingNodeClass The computing node class to use.
	 */
	public ComputingNodesGenerator(SimulationManager simulationManager,
			Class<? extends MobilityModel> mobilityModelClass, Class<? extends ComputingNode> computingNodeClass) {
		this.simulationManager = simulationManager;
		this.mobilityModelClass = mobilityModelClass;
		this.computingNodeClass = computingNodeClass;
		this.orchestratorsList = new ArrayList<>(simulationManager.getScenario().getDevicesCount());
		this.mistOnlyList = new ArrayList<>(simulationManager.getScenario().getDevicesCount());
		this.mistOnlyListSensorsExcluded = new ArrayList<>(simulationManager.getScenario().getDevicesCount());
		this.mistAndCloudListSensorsExcluded = new ArrayList<>(
				simulationManager.getScenario().getDevicesCount() + SimulationParameters.numberOfCloudDataCenters);
		this.mistAndEdgeListSensorsExcluded = new ArrayList<>(
				simulationManager.getScenario().getDevicesCount() + SimulationParameters.numberOfEdgeDataCenters);
		this.allNodesList = new ArrayList<>(simulationManager.getScenario().getDevicesCount()
				+ SimulationParameters.numberOfEdgeDataCenters + SimulationParameters.numberOfCloudDataCenters);
		this.allNodesListSensorsExcluded = new ArrayList<>(simulationManager.getScenario().getDevicesCount()
				+ SimulationParameters.numberOfEdgeDataCenters + SimulationParameters.numberOfCloudDataCenters);
	}

生成所有节点

	/**
	 * Generates all computing nodes, including the Cloud data centers, the edge
	 * ones, and the edge devices.
	 */
	public void generateDatacentersAndDevices() {

		// Generate Edge and Cloud data centers.
		generateDataCenters(SimulationParameters.cloudDataCentersFile, SimulationParameters.TYPES.CLOUD);

		generateDataCenters(SimulationParameters.edgeDataCentersFile, SimulationParameters.TYPES.EDGE_DATACENTER);

		// Generate edge devices.
		generateEdgeDevices();

		getSimulationManager().getSimulationLogger().print("%s - Datacenters and devices were generated",
				getClass().getSimpleName());

	}

生成所有边缘设备

	/**
	 * Generates edge devices
	 */
	public void generateEdgeDevices() {

		// Generate edge devices instances from edge devices types in xml file.
		try (InputStream devicesFile = new FileInputStream(SimulationParameters.edgeDevicesFile)) {

			DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();

			// Disable access to external entities in XML parsing, by disallowing DocType
			// declaration
			dbFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
			DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
			Document doc = dBuilder.parse(devicesFile);
			NodeList nodeList = doc.getElementsByTagName("device");
			Element edgeElement = null;

			// Load all devices types in edge_devices.xml file.
			for (int i = 0; i < nodeList.getLength(); i++) {
				Node edgeNode = nodeList.item(i);
				edgeElement = (Element) edgeNode;
				generateDevicesInstances(edgeElement);
			}

			// if percentage of generated devices is < 100%.
			if (mistOnlyList.size() < getSimulationManager().getScenario().getDevicesCount())
				getSimulationManager().getSimulationLogger().print(
						"%s - Wrong percentages values (the sum is inferior than 100%), check edge_devices.xml file !",
						getClass().getSimpleName());
			// Add more devices.
			if (edgeElement != null) {
				int missingInstances = getSimulationManager().getScenario().getDevicesCount() - mistOnlyList.size();
				for (int k = 0; k < missingInstances; k++) {
					ComputingNode newDevice = createComputingNode(edgeElement, SimulationParameters.TYPES.EDGE_DEVICE);
					insertEdgeDevice(newDevice);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

将新产生的边缘设备放入列表

	/**
	 * Puts the newly generated edge device in corresponding lists.
	 */
	protected void insertEdgeDevice(ComputingNode newDevice) {
		mistOnlyList.add(newDevice);
		allNodesList.add(newDevice);
		if (!newDevice.isSensor()) {
			mistOnlyListSensorsExcluded.add(newDevice);
			mistAndCloudListSensorsExcluded.add(newDevice);
			mistAndEdgeListSensorsExcluded.add(newDevice);
			allNodesListSensorsExcluded.add(newDevice);
		}
	}

产生边缘设备实例

	/**
	 * Generates the required number of instances for each type of edge devices.
	 * 
	 * @param type The type of edge devices.
	 */
	protected void generateDevicesInstances(Element type) {

		int instancesPercentage = Integer.parseInt(type.getElementsByTagName("percentage").item(0).getTextContent());

		// Find the number of instances of this type of devices
		int devicesInstances = getSimulationManager().getScenario().getDevicesCount() * instancesPercentage / 100;

		for (int j = 0; j < devicesInstances; j++) {
			if (mistOnlyList.size() > getSimulationManager().getScenario().getDevicesCount()) {
				getSimulationManager().getSimulationLogger().print(
						"%s - Wrong percentages values (the sum is superior than 100%%), check edge_devices.xml file !",
						getClass().getSimpleName());
				break;
			}

			try {
				insertEdgeDevice(createComputingNode(type, SimulationParameters.TYPES.EDGE_DEVICE));
			} catch (NoSuchAlgorithmException | NoSuchMethodException | SecurityException | InstantiationException
					| IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
				e.printStackTrace();
			}

		}
	}

产生云和边缘数据中心

	/**
	 * Generates the Cloud and Edge data centers.
	 * 
	 * @param file The configuration file.
	 * @param type The type, whether a CLOUD data center or an EDGE one.
	 */
	protected void generateDataCenters(String file, TYPES type) {

		// Fill list with edge data centers
		try (InputStream serversFile = new FileInputStream(file)) {
			DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();

			// Disable access to external entities in XML parsing, by disallowing DocType
			// declaration
			dbFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
			DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
			Document doc = dBuilder.parse(serversFile);
			NodeList datacenterList = doc.getElementsByTagName("datacenter");
			for (int i = 0; i < datacenterList.getLength(); i++) {
				Element datacenterElement = (Element) datacenterList.item(i);
				ComputingNode computingNode = createComputingNode(datacenterElement, type);
				if (computingNode.getType() == TYPES.CLOUD) {
					cloudOnlyList.add(computingNode);
					mistAndCloudListSensorsExcluded.add(computingNode);
					if (SimulationParameters.enableOrchestrators
							&& SimulationParameters.deployOrchestrators == "CLOUD") {
						orchestratorsList.add(computingNode);
					}
				} else {
					edgeOnlyList.add(computingNode);
					mistAndEdgeListSensorsExcluded.add(computingNode);
					if (SimulationParameters.enableOrchestrators
							&& SimulationParameters.deployOrchestrators == "EDGE") {
						orchestratorsList.add(computingNode);
					}
				}
				allNodesList.add(computingNode);
				allNodesListSensorsExcluded.add(computingNode);
				edgeAndCloudList.add(computingNode);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

创建计算节点

	/**
	 * Creates the computing nodes.
	 * 
	 * @see #generateDataCenters(String, TYPES)
	 * @see #generateDevicesInstances(Element)
	 * 
	 * @param datacenterElement The configuration file.
	 * @param type              The type, whether an MIST (edge) device, an EDGE
	 *                          data center, or a CLOUD one.
	 * @throws NoSuchAlgorithmException
	 * @throws SecurityException
	 * @throws NoSuchMethodException
	 * @throws InvocationTargetException
	 * @throws IllegalArgumentException
	 * @throws IllegalAccessException
	 * @throws InstantiationException
	 */
	protected ComputingNode createComputingNode(Element datacenterElement, SimulationParameters.TYPES type)
			throws NoSuchAlgorithmException, NoSuchMethodException, SecurityException, InstantiationException,
			IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		// SecureRandom is preferred to generate random values.
		Random random = SecureRandom.getInstanceStrong();
		Boolean mobile = false;
		double speed = 0;
		double minPauseDuration = 0;
		double maxPauseDuration = 0;
		double minMobilityDuration = 0;
		double maxMobilityDuration = 0;
		int xPosition = -1;
		int yPosition = -1;
		double idleConsumption = Double
				.parseDouble(datacenterElement.getElementsByTagName("idleConsumption").item(0).getTextContent());
		double maxConsumption = Double
				.parseDouble(datacenterElement.getElementsByTagName("maxConsumption").item(0).getTextContent());
		Location datacenterLocation = new Location(xPosition, yPosition);
		int numOfCores = Integer.parseInt(datacenterElement.getElementsByTagName("cores").item(0).getTextContent());
		double mips = Double.parseDouble(datacenterElement.getElementsByTagName("mips").item(0).getTextContent());
		double storage = Double.parseDouble(datacenterElement.getElementsByTagName("storage").item(0).getTextContent());
		double ram = Double.parseDouble(datacenterElement.getElementsByTagName("ram").item(0).getTextContent());

		Constructor<?> datacenterConstructor = computingNodeClass.getConstructor(SimulationManager.class, double.class,
				int.class, double.class, double.class);
		ComputingNode computingNode = (ComputingNode) datacenterConstructor.newInstance(getSimulationManager(), mips,
				numOfCores, storage, ram);

		computingNode.setAsOrchestrator(Boolean
				.parseBoolean(datacenterElement.getElementsByTagName("isOrchestrator").item(0).getTextContent()));

		if (computingNode.isOrchestrator())
			orchestratorsList.add(computingNode);

		computingNode.setEnergyModel(new EnergyModelComputingNode(maxConsumption, idleConsumption));

		if (type == SimulationParameters.TYPES.EDGE_DATACENTER) {
			String name = datacenterElement.getAttribute("name");
			computingNode.setName(name);
			Element location = (Element) datacenterElement.getElementsByTagName("location").item(0);
			xPosition = Integer.parseInt(location.getElementsByTagName("x_pos").item(0).getTextContent());
			yPosition = Integer.parseInt(location.getElementsByTagName("y_pos").item(0).getTextContent());
			datacenterLocation = new Location(xPosition, yPosition);

			for (int i = 0; i < edgeOnlyList.size(); i++)
				if (datacenterLocation.equals(edgeOnlyList.get(i).getMobilityModel().getCurrentLocation()))
					throw new IllegalArgumentException(
							" Each Edge Data Center must have a different location, check the \"edge_datacenters.xml\" file!");

			computingNode.setPeriphery(
					Boolean.parseBoolean(datacenterElement.getElementsByTagName("periphery").item(0).getTextContent()));

		} else if (type == SimulationParameters.TYPES.EDGE_DEVICE) {
			mobile = Boolean.parseBoolean(datacenterElement.getElementsByTagName("mobility").item(0).getTextContent());
			speed = Double.parseDouble(datacenterElement.getElementsByTagName("speed").item(0).getTextContent());
			minPauseDuration = Double
					.parseDouble(datacenterElement.getElementsByTagName("minPauseDuration").item(0).getTextContent());
			maxPauseDuration = Double
					.parseDouble(datacenterElement.getElementsByTagName("maxPauseDuration").item(0).getTextContent());
			minMobilityDuration = Double.parseDouble(
					datacenterElement.getElementsByTagName("minMobilityDuration").item(0).getTextContent());
			maxMobilityDuration = Double.parseDouble(
					datacenterElement.getElementsByTagName("maxMobilityDuration").item(0).getTextContent());
			computingNode.getEnergyModel().setBattery(
					Boolean.parseBoolean(datacenterElement.getElementsByTagName("battery").item(0).getTextContent()));
			computingNode.getEnergyModel().setBatteryCapacity(Double
					.parseDouble(datacenterElement.getElementsByTagName("batteryCapacity").item(0).getTextContent()));
			computingNode.getEnergyModel().setIntialBatteryPercentage(Double.parseDouble(
					datacenterElement.getElementsByTagName("initialBatteryLevel").item(0).getTextContent()));
			computingNode.getEnergyModel().setConnectivityType(
					datacenterElement.getElementsByTagName("connectivity").item(0).getTextContent());
			computingNode.enableTaskGeneration(Boolean
					.parseBoolean(datacenterElement.getElementsByTagName("generateTasks").item(0).getTextContent()));
			// Generate random location for edge devices
			datacenterLocation = new Location(random.nextInt(SimulationParameters.simulationMapLength),
					random.nextInt(SimulationParameters.simulationMapLength));
			getSimulationManager().getSimulationLogger()
					.deepLog("ComputingNodesGenerator- Edge device:" + mistOnlyList.size() + "    location: ( "
							+ datacenterLocation.getXPos() + "," + datacenterLocation.getYPos() + " )");
		}
		computingNode.setType(type);
		Constructor<?> mobilityConstructor = mobilityModelClass.getConstructor(SimulationManager.class, Location.class);
		MobilityModel mobilityModel = ((MobilityModel) mobilityConstructor.newInstance(simulationManager,
				datacenterLocation)).setMobile(mobile).setSpeed(speed).setMinPauseDuration(minPauseDuration)
				.setMaxPauseDuration(maxPauseDuration).setMinMobilityDuration(minMobilityDuration)
				.setMaxMobilityDuration(maxMobilityDuration);

		computingNode.setMobilityModel(mobilityModel);

		return computingNode;
	}

返回所有被设为编排器的计算机节点列表

	/**
	 * Returns the list containing computing nodes that have been selected as
	 * orchestrators (i.e. to make offloading decisions).
	 * 
	 * @return The list of orchestrators
	 */
	public List<ComputingNode> getOrchestratorsList() {
		return orchestratorsList;
	}

返回SimulationManager

	/**
	 * Returns the simulation Manager.
	 * 
	 * @return The simulation manager
	 */
	public SimulationManager getSimulationManager() {
		return simulationManager;
	}

得到所有的设备列表

	/**
	 * Gets the list containing all generated computing nodes.
	 * 
	 * @see #generateDatacentersAndDevices()
	 * 
	 * @return the list containing all generated computing nodes.
	 */
	public List<ComputingNode> getAllNodesList() {
		return this.allNodesList;
	}

得到边缘设备(包括传感器)

	/**
	 * Gets the list containing all generated edge devices including sensors (i.e.,
	 * devices with no computing resources).
	 * 
	 * @see #generateDevicesInstances(Element)
	 * 
	 * @return the list containing all edge devices including sensors.
	 */
	public List<ComputingNode> getMistOnlyList() {
		return this.mistOnlyList;
	}

返回所有边缘数据中心

	/**
	 * Gets the list containing all generated edge data centers / servers.
	 * 
	 * @see #generateDataCenters(String, TYPES)
	 * 
	 * @return the list containing all edge data centers and servers.
	 */
	public List<ComputingNode> getEdgeOnlyList() {
		return this.edgeOnlyList;
	}

返回所有云数据中心

	/**
	 * Gets the list containing only cloud data centers.
	 * 
	 * @see #generateDataCenters(String, TYPES)
	 * 
	 * @return the list containing all generated cloud data centers.
	 */
	public List<ComputingNode> getCloudOnlyList() {
		return this.cloudOnlyList;
	}

得到边缘设备(不包括传感器)和云数据中心

	/**
	 * Gets the list containing cloud data centers and edge devices (except
	 * sensors).
	 * 
	 * @see #generateDataCenters(String, TYPES)
	 * @see #generateDevicesInstances(Element)
	 * 
	 * @return the list containing cloud data centers and edge devices.
	 */
	public List<ComputingNode> getMistAndCloudListSensorsExcluded() {
		return this.mistAndCloudListSensorsExcluded;
	}

返回云和边缘计算中心

	/**
	 * Gets the list containing cloud and edge data centers.
	 * 
	 * @see #generateDataCenters(String, TYPES)
	 * 
	 * @return the list containing cloud and edge data centers.
	 */
	public List<ComputingNode> getEdgeAndCloudList() {
		return this.edgeAndCloudList;
	}

返回边缘数据中心和

	/**
	 * Gets the list containing edge data centers and edge devices (except sensors).
	 * 
	 * @see #generateDataCenters(String, TYPES)
	 * @see #generateDevicesInstances(Element)
	 * 
	 * @return the list containing edge data centers and edge devices.
	 */
	public List<ComputingNode> getMistAndEdgeListSensorsExcluded() {
		return this.mistAndEdgeListSensorsExcluded;
	}

返回所有边缘设备(不包括传感器)

	/**
	 * Gets the list containing all generated edge devices except sensors (i.e.,
	 * devices with no computing resources).
	 * 
	 * @see #generateDevicesInstances(Element)
	 * 
	 * @return the list containing all edge devices except sensors.
	 */
	public List<ComputingNode> getMistOnlyListSensorsExcluded() {
		return this.mistOnlyListSensorsExcluded;
	}

返回所有计算中心和设备(不包括传感器)

	/**
	 * Gets the list containing all computing nodes (except sensors).
	 * 
	 * @see #generateDataCenters(String, TYPES)
	 * @see #generateDevicesInstances(Element)
	 * 
	 * @return the list containing all data centers and devices except sensors.
	 */
	public List<ComputingNode> getAllNodesListSensorsExcluded() {
		return this.allNodesListSensorsExcluded;
	}
ADBOEX
关注
专栏目录
WPF仿微信保存与查看聊天记录
qq_44544363的博客
05-08 443
WPF仿微信保存与查看聊天记录 之前做了仿微信发送消息，当然也要有个聊天记录来保存消息内容啦，下面一起来看看 ViewModel中在服务器中创建用户与当前聊天好友的文件夹，以便存放聊天记录文件和图片文件，代码如下： /// <summary> /// 创建用户聊天文件 /// </summary> /// <param name="msg"></param> public virtual void
c#使用Json格式请求服务端数据
weixin_44484452的博客
05-08 1531
一、客户那边的接口需要登录后才能请求数据，接口采用basic验证方式，确保调用的合法性，防止出现未经验证的请求。验证登录流程：向系统发起登录验证请求，系统验证成功后返回一串验证码。然后每一个接口方法都需要在请求头中增加该验证码。 二、登录请求 1、请求内容的是json的格式，也就是键值对的格式 //获取用户名和密码 StatusCenter statusCenter = DataCenterManager.Default.StatusCenter; //字典 var re
PureEdgeSim（一）仿真器阅读笔记
5-StarrySky的博客
04-12 1209
PureEdgeSim仿真器阅读笔记 参考文献： 论文面向的问题： 虽然目前边缘计算和雾计算取得了一些进展，但是存在缺乏仿真工具的问题，尤其是在边缘计算的情况下，异构和受限设备以对等的方式合作并共享资源的情况下。 提出的解决方案： 提出了一个仿真工具包PureEdgeSim，它可以模拟资源管理策略，并从延迟、能耗、网络拥塞、资源利用率和任务成功率等方面评估云计算、雾计算和边缘计算环境的性能。并提出了一种基于模糊决策树的负载平衡算法。它利用强化学习，使其能够适应物联网环境变化，并实现物联网自我能力。同时描述
PureEdgeSim -locationmanager包-MobilityModel文件
ADEXOM的博客
11-11 75
PureEdgeSim -locationmanager包-MobilityModel文件
PureEdgeSim：PureEdgeSim：用于评估云，雾和纯边缘计算环境的性能的仿真框架
01-29
请引用为： Mechalikh，C.，Taktak，H.，Moussa，F .： PureEdgeSim：一种用于云，边缘和雾计算环境性能评估的仿真框架。 计算机科学与信息系统 要么 Mechalikh，C.，Taktak，H.，Moussa，F .： PureEdgeSim：用于评估云，雾和Pure Edge计算环境的性能的仿真工具包。 2019高性能计算与仿真国际会议（2019）700-707 想要查询更多的信息 在此处阅读维基： 可以在找到模拟教程 其他使用PureEdgeSim的出版物可以在找到 如有任何疑问，请通过与我联系。 基于PureEdgeSim和扩展的作品： SatEdgeSim：用于在卫星边缘计算环境中进行性能评估的建模和仿真的工具包，在了解更多信息。 1.背景 Edge and Mist（Extreme Edge）计算是两个新兴的计算范例，旨在通过将其应用程序引入网络边缘来克服云计算的局限性。 因此，减少了延迟和云工作量，并导致了更具扩展性的网络。 然而，在这些分布式环境中，许多设备需要彼此分担任务（以延长其寿命或最小化任务完成延迟），必须解决许多问题，例
PureEdgeSim使用操作步骤
5-StarrySky的博客
04-12 1306
PurEdgeSim:模拟软件导入说明 一：java开发环境安装以及配置 1：安装配置JDK https://blog.csdn.net/pu329289309/article/details/104883458/ 2；eclipse安装 https://www.cnblogs.com/caijiaming/p/10837083.html 二：项目导入 2.1 File→import 2.2 General →project from flod...
PureEdgeSim -scenariomanager包-SimulattionParameters文件
ADEXOM的博客
11-11 88
PureEdgeSim -scenariomanager包-SimulattionParameters文件
DatacenterManager:UNIX性能监控/趋势分析Java软件-开源
04-29
数秒之内即可进行远程库存和轮询... 通过为每个服务器提供主机名，用户名和密码（“一对一”）或通过自动CSV主机列表导入文件，可以自动盘点整个数据中心。 该软件可与其他UNIX软件（例如WinSCP和Putty等）配合使用！
推荐文章：探索未来计算的边界 —— PureEdgeSim深度解析与应用指南
最新发布
gitblog_00062的博客
06-09 411
推荐文章：探索未来计算的边界 —— PureEdgeSim深度解析与应用指南 PureEdgeSimPureEdgeSim: A simulation framework for performance evaluation of cloud, fog, and pure edge computing environments.项目地址:https://gitcode.com/gh_mirror...
PureEdgeSim -taskgenerator包-Task文件
ADEXOM的博客
11-09 100
PureEdgeSim -taskgenerator包 Task接口
云计算仿真工具
10-15
与云计算相关的算法有很多，使用cloudsim可以对云计算中的算法进行仿真。
云计算仿真工具cloudsim介绍
10-23
云计算仿真工具cloudsim介绍，环境配置，做仿真的步骤
PureEdgeSim
04-12
在研究生学习阶段发现的一个比较好的仿真工具，根据学习发现，可以根据配置文件，设置云计算，云边协同，还是边缘计算或者雾计算，算是比较全面的仿真软件。并且还可以保留截图，自带了一个桌面端的可视化界面，算是我用的里面比较全的仿真器了，这里免费分享给大家
PureEdgeSim设置文件（三）
5-StarrySky的博客
04-12 299
Edge devices XML PureEdgeSim还使用户能够生成数百甚至数千个异构设备。为此，用户将要在Edge_device.xml文件指定要生成的Edge设备的类型及其在设备中的百分比。然后，服务器管理器将根据建议的类型生成所需数量的Edge设备。 在本文件中，需要注意的参数，一个是百分比。举例说明，如果用户定义两种类型的设备，并将每种类型的百分比设置为50％，并将Edge设备的数量（在simulation_parameters.properties中）设置为1000个设备，则将生成500个类型
如何在eclipse中导入项目
weixin_43676381的博客
07-17 100
用导入方式 ： File->Import->General->Existing Project into WorkSpace->（选中你的项目就行了）
PureEdgeSim的例子
5-StarrySky的博客
04-12 595
写在之前，在PureEdgeSim的例子中，例子1-9全是覆盖了主类MainApplication中的main方法，然后执行更改其中个别设置，实现了不同的效果。 相关网站 CloudSim Plus: https://gitee.com/lumoondag/cloudsim-plus PureEdgeSim wiki: https://github.com/CharafeddineMechalikh/PureEdgeSim/wiki 该仿真器出版物： https://www.researchgate.net
PureEdgeSim设置文件（一）
5-StarrySky的博客
04-12 318
simulation parameters文件中： 它对所有模拟参数进行分组，包括模拟环境设置（模拟时间，初始化时间，更新间隔等），模型设置（移动性，能源，网络和任务生成模型使用的参数），其他以此类推。其中要说明的是orchestration_architectures，其用来选择架构计算范例。比如只用云计算范例，就选择CLOUD_ONLY即可 # default config file ################## 仿真参数 # simulation_time 整数 > = 1 模拟持续时间
PureEdgeSim（2）：数据信息
5-StarrySky的博客
04-12 300
大概信息： ​ 1、按迭代次数采用某编排架构和某编排算法下的图片数据，位于…\simulation_1文件夹下 ​ 2、编排结构下的图片数据，在…\Final results\Architectures文件中，更多的是从一个编排结构来说说明数据（图片数据） ​ 3、编排算法下的图片数据，在…\Final results\Algorithms文件夹中，更多的是从一个编排算法来说明数据（图片数据） 缺陷：没有实时的具体数据，只有一个总体的具体数据 数值数据 Orchestration architecture：
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值