### VR Game Simulation Setup in Ifogsim

Source: https://context7.com/cloudslab/ifogsim/llms.txt

This Java code sets up and runs an end-to-end simulation for a VR game application within a 3-tier fog hierarchy. It configures the application modules, edges, tuple mappings, and the fog device topology. Ensure CloudSim is initialized before starting the simulation.

```java
import org.cloudbus.cloudsim.core.CloudSim;
import org.fog.application.*;
import org.fog.application.selectivity.FractionalSelectivity;
import org.fog.entities.*;
import org.fog.placement.*;
import org.fog.utils.TimeKeeper;
import org.fog.utils.distribution.DeterministicDistribution;
import java.util.*;

public class VRGameFog {
    public static void main(String[] args) throws Exception {
        Log.disable();
        CloudSim.init(1, Calendar.getInstance(), false);

        FogBroker broker = new FogBroker("broker");
        Application app = Application.createApplication("vr_game", broker.getId());

        app.addAppModule("client", 10);
        app.addAppModule("concentration_calculator", 10);
        app.addAppModule("connector", 10);

        app.addAppEdge("EEG", "client", 3000, 500, "EEG", Tuple.UP, AppEdge.SENSOR);
        app.addAppEdge("client", "concentration_calculator", 3500, 500,
                "_SENSOR", Tuple.UP, AppEdge.MODULE);
        app.addAppEdge("concentration_calculator", "connector", 100, 1000, 1000,
                "PLAYER_GAME_STATE", Tuple.UP, AppEdge.MODULE);
        app.addAppEdge("concentration_calculator", "client", 14, 500,
                "CONCENTRATION", Tuple.DOWN, AppEdge.MODULE);
        app.addAppEdge("client", "DISPLAY", 1000, 500, "SELF_STATE_UPDATE",
                Tuple.DOWN, AppEdge.ACTUATOR);

        app.addTupleMapping("client", "EEG", "_SENSOR",
                new FractionalSelectivity(0.9));
        app.addTupleMapping("concentration_calculator", "_SENSOR", "CONCENTRATION",
                new FractionalSelectivity(1.0));
        app.addTupleMapping("client", "CONCENTRATION", "SELF_STATE_UPDATE",
                new FractionalSelectivity(1.0));

        app.setLoops(List.of(new AppLoop(
                List.of("EEG","client","concentration_calculator","client","DISPLAY"))));

        List<FogDevice> fogDevices = new ArrayList<>();
        List<Sensor> sensors = new ArrayList<>();
        List<Actuator> actuators = new ArrayList<>();

        FogDevice cloud = createFogDevice("cloud", 44800, 40000, 100, 10000,
                0, 0.01, 16*103, 16*83.25);
        cloud.setParentId(-1);
        fogDevices.add(cloud);

        FogDevice proxy = createFogDevice("proxy", 2800, 4000, 10000, 10000,
                1, 0.0, 107.339, 83.4333);
        proxy.setParentId(cloud.getId());
        proxy.setUplinkLatency(100);
        fogDevices.add(proxy);

        FogDevice mobile = createFogDevice("m-0", 1000, 1000, 10000, 270,
                3, 0, 87.53, 82.44);
        mobile.setParentId(proxy.getId());
        mobile.setUplinkLatency(2);
        fogDevices.add(mobile);

        Sensor sensor = new Sensor("s-0", "EEG", broker.getId(), "vr_game",
                new DeterministicDistribution(5.0));
        sensor.setGatewayDeviceId(mobile.getId());
        sensor.setLatency(6.0);
        sensors.add(sensor);

        Actuator disp = new Actuator("a-0", broker.getId(), "vr_game", "DISPLAY");
        disp.setGatewayDeviceId(mobile.getId());
        disp.setLatency(1.0);
        actuators.add(disp);

        ModuleMapping mapping = ModuleMapping.createModuleMapping();
        mapping.addModuleToDevice("connector", "cloud");

        Controller ctrl = new Controller("ctrl", fogDevices, sensors, actuators);
        ctrl.submitApplication(app, 0,
                new ModulePlacementEdgewards(fogDevices, sensors, actuators,
                        app, mapping));

        TimeKeeper.getInstance().setSimulationStartTime(
                Calendar.getInstance().getTimeInMillis());
        CloudSim.startSimulation();
        CloudSim.stopSimulation();

        System.out.println("Loop latencies: "
                + TimeKeeper.getInstance().getLoopIdToCurrentAverage());
        // Output: Loop latencies: {0=12.34}
    }
}
```

--------------------------------

### Initialize and Run MicroservicesController

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Initializes the MicroservicesController with fog devices, sensors, applications, and placement logic. Dispatches placement requests and starts the simulation.

```java
import org.fog.placement.*;
import org.fog.entities.PlacementRequest;

List<Integer> clusterLevelIds = List.of(2); // cluster at level 2
double clusterLatency = 2.0; // ms

// Select placement algorithm
int placementAlgo = PlacementLogicFactory.DISTRIBUTED_MICROSERVICES_PLACEMENT;
// Alternatives: CLUSTERED_MICROSERVICES_PLACEMENT

// Build FON monitor map: fonId -> list of devices it monitors
Map<Integer, List<FogDevice>> monitored = new HashMap<>();
for (FogDevice f : fogDevices) {
    MicroserviceFogDevice msf = (MicroserviceFogDevice) f;
    if (msf.getDeviceType().equals(MicroserviceFogDevice.FON) ||
        msf.getDeviceType().equals(MicroserviceFogDevice.CLOUD)) {
        monitored.put(f.getId(), List.of(f));
        msf.setFonID(f.getId());
    }
    if (msf.getDeviceType().equals(MicroserviceFogDevice.CLIENT)) {
        msf.setFonID(f.getParentId());
    }
}

MicroservicesController controller = new MicroservicesController(
        "controller", fogDevices, sensors, applications,
        clusterLevelIds, clusterLatency, placementAlgo, monitored);

// Generate placement requests: one per sensor (client entry point)
List<PlacementRequest> placementRequests = new ArrayList<>();
for (Sensor s : sensors) {
    Map<String, Integer> placed = Map.of("client", s.getGatewayDeviceId());
    placementRequests.add(new PlacementRequest(
            s.getAppId(), s.getId(), s.getGatewayDeviceId(), placed));
}

controller.submitPlacementRequests(placementRequests, 0);

TimeKeeper.getInstance().setSimulationStartTime(
        Calendar.getInstance().getTimeInMillis());
CloudSim.startSimulation();
CloudSim.stopSimulation();

```

--------------------------------

### Constrain Module Placement with Prefixes

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Forces a specific microservice module to be placed on devices whose names start with a given prefix. Must be called after all modules/edges are defined, before createDAG().

```java
// Force ECG_Analyser to run on the cloud
application.setSpecialPlacementInfo("ECG_Analyser", "cloud");

// Force ECGFeature_Extractor to only run on fog nodes starting with "proxy"
application.setSpecialPlacementInfo("ECGFeature_Extractor", "proxy");

// Must be called after all modules/edges are defined, before createDAG()
application.createDAG();

```

--------------------------------

### Initialize Git Repository

Source: https://github.com/cloudslab/ifogsim/blob/main/README.md

Initialize an empty Git repository in your project directory. This is the first step when setting up iFogSim2 in Eclipse IDE.

```bash
git init
```

--------------------------------

### Initialize CloudSim Engine

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Initialize the CloudSim engine before creating any simulation entities. Disable verbose logging if not needed.

```java
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.core.CloudSim;
import java.util.Calendar;

// Disable verbose CloudSim logging
Log.disable();

int numCloudUsers = 1;
Calendar calendar = Calendar.getInstance();
boolean traceFlag = false;

// Must be called before creating any fog devices, sensors, or brokers
CloudSim.init(numCloudUsers, calendar, traceFlag);
```

--------------------------------

### Define Application Modules and Dependencies

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Creates an application model, adds modules with their resource requirements, defines data flow edges between modules, and sets special placement constraints. Finalizes the application by creating the DAG.

```java
Application application = Application.createApplication("ECG_monitoring", userId);

application.addAppModule("client",              128, 605, 100);
application.addAppModule("ECGFeature_Extractor", 256, 630, 200);
application.addAppModule("ECG_Analyser",         512, 100, 2000);

application.addAppEdge("ECG", "client", 3000, 500, "ECG",
        Tuple.UP, AppEdge.SENSOR);
application.addAppEdge("client", "ECGFeature_Extractor", 3500, 500,
        "_SENSOR", Tuple.UP, AppEdge.MODULE);
application.addAppEdge("ECGFeature_Extractor", "ECG_Analyser", 100, 10000,
        1000, "ECG_FEATURES", Tuple.UP, AppEdge.MODULE);

application.setSpecialPlacementInfo("ECG_Analyser", "cloud");

// Must be called to finalize the DAG for microservice-based controllers
application.createDAG();

```

--------------------------------

### ModuleMapping: Pin Modules to Specific Fog Devices

Source: https://context7.com/cloudslab/ifogsim/llms.txt

ModuleMapping allows you to statically assign application modules to specific fog devices, overriding the default placement algorithm. Use addModuleToDevice to specify the module and the target device name.

```java
import org.fog.placement.ModuleMapping;

ModuleMapping moduleMapping = ModuleMapping.createModuleMapping();

// Force the "connector" module to always run on the cloud
moduleMapping.addModuleToDevice("connector", "cloud");

// Pin "client" module to each mobile device
for (FogDevice device : fogDevices) {
    if (device.getName().startsWith("m-")) {
        moduleMapping.addModuleToDevice("client", device.getName());
    }
}
// Remaining unspecified modules are placed by the chosen placement policy
```

--------------------------------

### Clone iFogSim2 Git Repository

Source: https://github.com/cloudslab/ifogsim/blob/main/README.md

Clone the iFogSim2 Git repository to your desired folder. This is the initial step for setting up iFogSim2 in IntelliJ IDEA.

```bash
git clone https://github.com/Cloudslab/iFogSim
```

--------------------------------

### Create FogBroker for Simulation

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Create a FogBroker to represent the user or application owner. Its ID is used for registering entities and applications.

```java
import org.fog.entities.FogBroker;

FogBroker broker = new FogBroker("broker");
int userId = broker.getId(); // used when registering sensors, actuators, and applications
```

--------------------------------

### Configure Global Simulation Settings in CloudSim

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Set global simulation constants to control clustering, resource management, and device costs. Ensure only one clustering mode is enabled at a time.

```java
import org.fog.utils.Config;

// Clustering mode (use only one at a time)
Config.ENABLE_STATIC_CLUSTERING  = false; // cluster by hierarchy level
Config.ENABLE_DYNAMIC_CLUSTERING = true;  // cluster by geographic proximity
Config.Node_Communication_RANGE  = 300.0; // clustering range in meters
Config.clusteringLatency         = 2.0;   // inter-cluster link latency (ms)

// Resource management polling interval
Config.RESOURCE_MANAGE_INTERVAL = 100;    // ms
Config.MAX_SIMULATION_TIME      = 2000;   // ms

// Standard fog device hardware/cost defaults
Config.FOG_DEVICE_ARCH         = "x86";
Config.FOG_DEVICE_OS           = "Linux";
Config.FOG_DEVICE_TIMEZONE     = 10.0;
Config.FOG_DEVICE_COST         = 3.0;
Config.FOG_DEVICE_COST_PER_BW  = 0.0;
```

--------------------------------

### ModulePlacementMapping: Static Mapping Placement

Source: https://context7.com/cloudslab/ifogsim/llms.txt

ModulePlacementMapping enforces exact module-to-device bindings defined in a ModuleMapping without any automatic optimization. This is useful for testing specific configurations.

```java
import org.fog.placement.*;

// All modules pinned explicitly — no dynamic placement
ModuleMapping strictMapping = ModuleMapping.createModuleMapping();
strictMapping.addModuleToDevice("connector", "cloud");
strictMapping.addModuleToDevice("concentration_calculator", "cloud");
for (FogDevice d : fogDevices) {
    if (d.getName().startsWith("m-"))
        strictMapping.addModuleToDevice("client", d.getName());
}

controller.submitApplication(application, 0,
        new ModulePlacementMapping(fogDevices, application, strictMapping));
```

--------------------------------

### Create FogDevice Hierarchy

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Define and create FogDevices representing compute nodes (cloud, proxy, gateway) with specified characteristics and network connections. Devices form a parent-child tree hierarchy.

```java
import org.cloudbus.cloudsim.*;
import org.cloudbus.cloudsim.power.PowerHost;
import org.cloudbus.cloudsim.sdn.overbooking.*;
import org.fog.entities.FogDevice;
import org.fog.entities.FogDeviceCharacteristics;
import org.fog.policy.AppModuleAllocationPolicy;
import org.fog.scheduler.StreamOperatorScheduler;
import org.fog.utils.FogLinearPowerModel;
import org.fog.utils.FogUtils;
import java.util.*;

private static FogDevice createFogDevice(String name, long mips, int ram, 
        long upBw, long downBw, int level, double ratePerMips, 
        double busyPower, double idlePower) throws Exception {

    List<Pe> peList = new ArrayList<>();
    peList.add(new Pe(0, new PeProvisionerOverbooking(mips)));

    int hostId = FogUtils.generateEntityId();
    PowerHost host = new PowerHost(hostId, 
            new RamProvisionerSimple(ram),
            new BwProvisionerOverbooking(10000),
            1000000L,
            peList,
            new StreamOperatorScheduler(peList),
            new FogLinearPowerModel(busyPower, idlePower));

    FogDeviceCharacteristics chars = new FogDeviceCharacteristics(
            "x86", "Linux", "Xen", host,
            10.0, 3.0, 0.05, 0.001, 0.0);

    FogDevice device = new FogDevice(name, chars,
            new AppModuleAllocationPolicy(List.of(host)),
            new LinkedList<>(), 10, upBw, downBw, 0, ratePerMips);

    device.setLevel(level); // 0=Cloud, 1=Proxy, 2=Gateway, 3=Mobile
    return device;
}

// Build a 3-tier hierarchy
FogDevice cloud = createFogDevice("cloud", 44800, 40000, 100, 10000, 
        0, 0.01, 16*103, 16*83.25);
cloud.setParentId(-1); // cloud has no parent

FogDevice proxy = createFogDevice("proxy-server", 2800, 4000, 10000, 10000, 
        1, 0.0, 107.339, 83.4333);
proxy.setParentId(cloud.getId());
proxy.setUplinkLatency(100); // ms latency to parent

FogDevice gateway = createFogDevice("gateway-0", 2800, 4000, 10000, 10000, 
        2, 0.0, 107.339, 83.4333);
gateway.setParentId(proxy.getId());
gateway.setUplinkLatency(4);

```

--------------------------------

### Add AppModule with Explicit Resource Parameters

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Use the overloaded addAppModule method to specify MIPS and storage in addition to RAM, which is useful for microservice scenarios.

```java
// addAppModule(name, ramMB, mips, storageMB)
application.addAppModule("client",              128, 605, 100);
application.addAppModule("ECGFeature_Extractor", 256, 630, 200);
application.addAppModule("ECG_Analyser",         512, 100, 2000);
```

--------------------------------

### ModulePlacementEdgewards: Greedy Edge-First Placement

Source: https://context7.com/cloudslab/ifogsim/llms.txt

ModulePlacementEdgewards implements a greedy strategy to place modules as close to sensors as possible, falling back to higher levels if resources are insufficient. This is used when submitting an application to the controller.

```java
import org.fog.placement.*;

Controller controller = new Controller("master-controller",
        fogDevices, sensors, actuators);

// Edgewards placement: modules placed as close to sensors as possible
controller.submitApplication(application, 0,
        new ModulePlacementEdgewards(fogDevices, sensors, actuators,
                application, moduleMapping));

TimeKeeper.getInstance().setSimulationStartTime(
        Calendar.getInstance().getTimeInMillis());
CloudSim.startSimulation();
CloudSim.stopSimulation();
// After stopSimulation(), TimeKeeper contains per-loop average latency data
```

--------------------------------

### Initialize and Use LocationHandler for Mobility and Placement

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Initialize LocationHandler with DataParser to manage geo-location data and user mobility. Use it to parse resource and user information, determine parent devices, and link simulation entities to their data records.

```java
import org.fog.mobilitydata.DataParser;
import org.fog.mobilitydata.References;
import org.fog.placement.LocationHandler;

DataParser dataObject = new DataParser();
LocationHandler locator = new LocationHandler(dataObject);

// Parse resource topology (cloud/proxy/gateway positions)
locator.parseResourceInfo();

// Parse user mobility traces
Map<Integer, Integer> mobilityPattern = Map.of(
        1, References.DIRECTIONAL_MOBILITY,
        2, References.DIRECTIONAL_MOBILITY);
locator.parseUserInfo(mobilityPattern, References.dataset_reference);

// Get resource IDs at a specific hierarchy level
List<String> cloudIds   = locator.getLevelWiseResources(locator.getLevelID("Cloud"));
List<String> gatewayIds = locator.getLevelWiseResources(locator.getLevelID("Gateway"));

// Link a simulation entity ID to its dataset record
locator.linkDataWithInstance(fogDevice.getId(), cloudIds.get(0));

// Determine the nearest parent device at setup time
int parentId = locator.determineParent(fogDevice.getId(), References.SETUP_TIME);
fogDevice.setParentId(parentId);

// Get mobile user dataset IDs for linking to mobile fog devices
List<String> mobileDataIds = locator.getMobileUserDataId();
locator.linkDataWithInstance(mobileFogDevice.getId(), mobileDataIds.get(0));
```

--------------------------------

### Configure FogLinearPowerModel for Energy

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Model device power consumption using a linear function of CPU utilization. Specify busy and idle power values.

```java
import org.fog.utils.FogLinearPowerModel;

// busyPower=107.339W at 100% utilization, idlePower=83.4333W at 0%
FogLinearPowerModel powerModel = new FogLinearPowerModel(107.339, 83.4333);

double powerAt50Percent = powerModel.getPower(0.5); // ~95.39W
double powerAt100Percent = powerModel.getPower(1.0); // 107.339W
double powerAtIdle = powerModel.getPower(0.0);       // 83.4333W
```

--------------------------------

### Define a Deterministic Sensor

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Create a Sensor that emits tuples at a fixed interval. Ensure the tuple type matches the AppEdge source and attach it to a gateway FogDevice.

```java
import org.fog.entities.Sensor;
import org.fog.utils.distribution.DeterministicDistribution;

// Sensor that fires every 5ms deterministically
Sensor eegSensor = new Sensor(
        "sensor-mobile-0",    // sensor name
        "EEG",                // tuple type emitted (must match AppEdge source)
        userId,
        appId,
        new DeterministicDistribution(5.0) // inter-transmission interval in ms
);
eegSensor.setGatewayDeviceId(mobile.getId()); // attach to mobile fog device
eegSensor.setLatency(6.0); // transmission latency to gateway in ms

sensors.add(eegSensor);
```

--------------------------------

### Controller: Standard Simulation Management

Source: https://context7.com/cloudslab/ifogsim/llms.txt

The Controller class manages application lifecycle, latency maps, and dispatches placement decisions. Use it to submit applications with specified placement policies.

```java
import org.fog.placement.Controller;

Controller controller = new Controller(
        "master-controller",  // name
        fogDevices,           // all FogDevice instances in the topology
        sensors,              // all Sensor instances
        actuators             // all Actuator instances
);

// submitApplication(app, launchDelay, placementPolicy)
controller.submitApplication(application, 0,
        new ModulePlacementEdgewards(fogDevices, sensors, actuators,
                application, moduleMapping));
```

--------------------------------

### Enable Dynamic Clustering in FogSim

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Configure FogSim to enable dynamic clustering and set communication parameters. This is useful for peer-to-peer cluster links and lateral tuple routing.

```java
import org.fog.placement.ClusteringController;
import org.fog.utils.Config;

// Enable dynamic clustering
Config.ENABLE_DYNAMIC_CLUSTERING = true;
Config.Node_Communication_RANGE = 300.0; // meters
Config.clusteringLatency = 2.0;          // ms between cluster peers

List<Integer> clusteringLevels = new ArrayList<>();
clusteringLevels.add(2); // cluster devices at hierarchy level 2 (gateways)

ClusteringController controller = new ClusteringController(
        "master-controller", fogDevices, sensors, actuators,
        locator, clusteringLevels);

controller.submitApplication(application, 0,
        new ModulePlacementMobileEdgewardsCluster(fogDevices, sensors,
                actuators, application, moduleMapping, true));
```

--------------------------------

### Add iFogSim2 Git Repository as Origin Remote

Source: https://github.com/cloudslab/ifogsim/blob/main/README.md

Add the iFogSim2 Git repository as the 'origin' remote. This command is used in Eclipse IDE to link your local repository to the remote iFogSim2 repository.

```bash
git remote add origin https://github.com/Cloudslab/iFogSim
```

--------------------------------

### Define Microservice-Capable Fog Node

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Instantiate MicroserviceFogDevice with specific roles like CLOUD, FCN, or FON. Configure device properties, parent-child relationships, and cluster memberships for distributed orchestration.

```java
import org.fog.entities.MicroserviceFogDevice;

// Device types: CLIENT, FCN (Fog Computation Node), FON (Fog Orchestration Node), CLOUD
MicroserviceFogDevice cloud = new MicroserviceFogDevice(
        "cloud", characteristics, allocationPolicy,
        storageList, 10,
        /*uplinkBw=*/100, /*downlinkBw=*/12500000,
        /*clusterLinkBw=*/1250000, /*uplinkLatency=*/0,
        /*ratePerMips=*/0.01,
        MicroserviceFogDevice.CLOUD);
cloud.setParentId(-1);

MicroserviceFogDevice fon = new MicroserviceFogDevice(
        "proxy-server-0", characteristics, allocationPolicy,
        storageList, 10, 12500000, 1250000, 1250000, 0, 0.0,
        MicroserviceFogDevice.FON);
fon.setParentId(cloud.getId());
fon.setUplinkLatency(150);

// Configure cluster connections among sibling FON nodes
fon.setClusterMembers(List.of(siblingFon.getId()));
fon.setClusterMembersToLatencyMap(Map.of(siblingFon.getId(), 2.0));
fon.setIsInCluster(true);

// Assign FON orchestrator for CLIENT devices
clientDevice.setFonID(parentFon.getId());
```

--------------------------------

### Pull iFogSim2 Repository Contents

Source: https://github.com/cloudslab/ifogsim/blob/main/README.md

Pull the contents of the iFogSim2 repository from the 'origin' remote to your local machine. This command is used in Eclipse IDE to download the project files.

```bash
git pull origin main
```

--------------------------------

### MobilityController: Mobility-Aware Application Management

Source: https://context7.com/cloudslab/ifogsim/llms.txt

MobilityController extends Controller to handle user mobility by reading location data and triggering module migrations. It requires initialization with a LocationHandler.

```java
import org.fog.placement.*;
import org.fog.mobilitydata.*;

DataParser dataObject = new DataParser();
LocationHandler locator = new LocationHandler(dataObject);

// Parse mobility dataset and link user IDs to mobility patterns
Map<Integer, Integer> userMobilityPattern = new HashMap<>();
userMobilityPattern.put(1, References.DIRECTIONAL_MOBILITY);
locator.parseUserInfo(userMobilityPattern, References.dataset_reference);
locator.parseResourceInfo();

// Link each fog device to its location data record
locator.linkDataWithInstance(cloud.getId(),
        locator.getLevelWiseResources(locator.getLevelID("Cloud")).get(0));

MobilityController mobController = new MobilityController(
        "master-controller", fogDevices, sensors, actuators, locator);

mobController.submitApplication(application, 0,
        new ModulePlacementMobileEdgewards(fogDevices, sensors, actuators,
                application, moduleMapping));
```

--------------------------------

### Track Simulation Latency with TimeKeeper

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Records per-loop latency statistics during the simulation. Retrieve average latency per AppLoop after simulation stops.

```java
import org.fog.utils.TimeKeeper;
import java.util.Calendar;

// Before starting simulation
TimeKeeper.getInstance().setSimulationStartTime(
        Calendar.getInstance().getTimeInMillis());

CloudSim.startSimulation();
CloudSim.stopSimulation();

// After simulation: retrieve average latency per defined AppLoop
Map<Integer, Double> loopAvgLatency =
        TimeKeeper.getInstance().getLoopIdToCurrentAverage();

for (Map.Entry<Integer, Double> entry : loopAvgLatency.entrySet()) {
    System.out.println("Loop " + entry.getKey()
            + " avg latency: " + entry.getValue() + " ms");
}
// Example output:
// Loop 0 avg latency: 12.45 ms

```

--------------------------------

### Define Application DAG with Modules and Edges

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Model a streaming dataflow application by defining modules and edges that represent processing vertices and data channels. Specify selectivity for tuple mapping.

```java
import org.fog.application.*;
import org.fog.application.selectivity.FractionalSelectivity;
import org.fog.entities.Tuple;

Application app = Application.createApplication("vr_game", userId);

// --- Modules (processing vertices) ---
// addAppModule(name, ramMB)
app.addAppModule("client", 10);
app.addAppModule("concentration_calculator", 10);
app.addAppModule("connector", 10);

// --- Edges (data channels) ---
// addAppEdge(src, dst, cpuLength, nwLength, tupleType, direction, edgeType)
// SENSOR edge: from a physical sensor name to a module
app.addAppEdge("EEG", "client", 3000, 500, "EEG", Tuple.UP, AppEdge.SENSOR);
// MODULE edge: between two processing modules
app.addAppEdge("client", "concentration_calculator", 3500, 500, "_SENSOR",
        Tuple.UP, AppEdge.MODULE);
// Periodic MODULE edge: period=1000ms
app.addAppEdge("concentration_calculator", "connector", 100, 1000, 1000,
        "PLAYER_GAME_STATE", Tuple.UP, AppEdge.MODULE);
// Downstream edge back to client
app.addAppEdge("concentration_calculator", "client", 14, 500,
        "CONCENTRATION", Tuple.DOWN, AppEdge.MODULE);
// ACTUATOR edge: from a module to a physical actuator type
app.addAppEdge("client", "DISPLAY", 1000, 500, "SELF_STATE_UPDATE",
        Tuple.DOWN, AppEdge.ACTUATOR);

// --- Selectivity: input-to-output tuple ratio per module ---
// addTupleMapping(module, inputTupleType, outputTupleType, selectivityModel)
app.addTupleMapping("client", "EEG", "_SENSOR", new FractionalSelectivity(0.9));
app.addTupleMapping("concentration_calculator", "_SENSOR", "CONCENTRATION",
        new FractionalSelectivity(1.0));
app.addTupleMapping("client", "CONCENTRATION", "SELF_STATE_UPDATE",
        new FractionalSelectivity(1.0));

// --- Loops: latency monitoring paths ---
final AppLoop loop1 = new AppLoop(List.of(
        "EEG", "client", "concentration_calculator", "client", "DISPLAY"));
app.setLoops(List.of(loop1));
```

--------------------------------

### Sensor Transmission Timing Distributions

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Utilize different distributions to control sensor inter-transmission timing. The getNextValue() method retrieves the next interval based on the distribution.

```java
import org.fog.utils.distribution.DeterministicDistribution;
import org.fog.utils.distribution.NormalDistribution;
import org.fog.utils.distribution.UniformDistribution;

// Fixed interval: fires exactly every 10ms
Distribution det = new DeterministicDistribution(10.0);

// Normal distribution: mean=10ms, std_dev=2ms
Distribution norm = new NormalDistribution(10.0, 2.0);

// Uniform distribution: random interval between 5ms and 15ms
Distribution uni = new UniformDistribution(5.0, 15.0);

// Get next transmission interval
double nextInterval = det.getNextValue(); // always 10.0
```

--------------------------------

### FractionalSelectivity: Control Tuple Output Probability

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Use FractionalSelectivity to define the probability that an incoming tuple generates an outgoing tuple. Instantiate with the desired probability.

```java
import org.fog.application.selectivity.FractionalSelectivity;

// 90% of incoming EEG tuples produce a _SENSOR output tuple
FractionalSelectivity sel = new FractionalSelectivity(0.9);

boolean shouldEmit = sel.canSelect(); // true ~90% of calls
double meanRate   = sel.getMeanRate(); // 0.9
```

--------------------------------

### Generate Synthetic Mobility Data

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Use RandomMobilityGenerator to create CSV mobility trace files for simulated users. Specify the mobility model, user index, dataset path, and whether to overwrite existing files.

```java
import org.fog.mobilitydata.RandomMobilityGenerator;
import org.fog.mobilitydata.References;

RandomMobilityGenerator randMobilityGenerator = new RandomMobilityGenerator();

int numberOfUsers = 3;
for (int i = 0; i < numberOfUsers; i++) {
    // createRandomData(mobilityModel, userIndex, datasetPath, overwrite)
    randMobilityGenerator.createRandomData(
            References.random_walk_mobility_model,
            i + 1,
            References.dataset_random,
            false // don't overwrite existing files
    );
}
// Generated files: dataset/random/1.csv, 2.csv, 3.csv
```

--------------------------------

### Define an Actuator

Source: https://context7.com/cloudslab/ifogsim/llms.txt

Instantiate an Actuator to receive result tuples and model physical actions. The actuator type must match an AppEdge destination.

```java
import org.fog.entities.Actuator;

Actuator display = new Actuator(
        "actuator-mobile-0",  // actuator name
        userId,
        appId,
        "DISPLAY"             // actuator type (matched by AppEdge destination)
);
display.setGatewayDeviceId(mobile.getId());
display.setLatency(1.0); // ms from gateway to actuator

actuators.add(display);
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.