feat: invert router processing speed units (#260)

Closes #234

This PR inverts the units that the router processing speed is
represented in.

Author: MegaRedHand

src/types/data-devices/dRouter.ts

@@ -11,24 +11,25 @@ import { DataNetworkDevice } from "./dNetworkDevice";
 import { ROUTER_CONSTANTS } from "../../utils/constants/router_constants";
 
 export class DataRouter extends DataNetworkDevice {
-  packetQueueSize: number;
+  private packetQueueSize: number;
   private packetQueue: PacketQueue;
-  // Time in ms to process a single byte
-  timePerByte: number;
+  // Number of bytes to process per second
+  private bytesPerSecond: number;
   // Number of bytes processed
   private processingProgress = 0;
+
   routingTable: RoutingTableEntry[];
 
   constructor(graphData: RouterDataNode, datagraph: DataGraph) {
     super(graphData, datagraph);
     this.packetQueueSize =
       graphData.packetQueueSize ?? ROUTER_CONSTANTS.PACKET_QUEUE_MAX_SIZE;
     this.packetQueue = new PacketQueue(this.packetQueueSize);
-    this.timePerByte =
-      graphData.timePerByte ?? ROUTER_CONSTANTS.PROCESSING_SPEED;
+    this.bytesPerSecond =
+      graphData.bytesPerSecond ?? ROUTER_CONSTANTS.PROCESSING_SPEED;
     this.routingTable = graphData.routingTable ?? [];
     console.log("packetQueueSize Dr", this.packetQueueSize);
-    console.log("processingSpeed Dr", this.timePerByte);
+    console.log("processingSpeed Dr", this.bytesPerSecond);
   }
 
   setMaxQueueSize(newSize: number) {
@@ -37,8 +38,8 @@ export class DataRouter extends DataNetworkDevice {
     this.packetQueueSize = newSize;
   }
 
-  setTimePerByte(newTime: number) {
-    this.timePerByte = newTime;
+  setBytesPerSecond(newTime: number) {
+    this.bytesPerSecond = newTime;
     console.log("Time per byte set to Dr", newTime);
   }
 
@@ -48,7 +49,7 @@ export class DataRouter extends DataNetworkDevice {
       type: DeviceType.Router,
       routingTable: this.routingTable,
       packetQueueSize: this.packetQueue.getMaxQueueSize(),
-      timePerByte: this.timePerByte,
+      bytesPerSecond: this.bytesPerSecond,
     };
   }
 
@@ -87,13 +88,12 @@ export class DataRouter extends DataNetworkDevice {
   }
 
   getPacketsToProcess(timeMs: number): IPv4Packet | null {
-    this.processingProgress += timeMs;
+    this.processingProgress += (this.bytesPerSecond * timeMs) / 1000;
     const packetLength = this.packetQueue.getHead()?.totalLength;
-    const progressNeeded = this.timePerByte * packetLength;
-    if (this.processingProgress < progressNeeded) {
+    if (this.processingProgress < packetLength) {
       return null;
     }
-    this.processingProgress -= progressNeeded;
+    this.processingProgress -= packetLength;
     return this.packetQueue.dequeue();
   }
 

src/types/graphs/datagraph.ts

@@ -61,7 +61,7 @@ export interface RouterDataNode extends NetworkDataNode {
   type: DeviceType.Router;
   routingTable?: RoutingTableEntry[];
   packetQueueSize: number;
-  timePerByte: number;
+  bytesPerSecond: number;
 }
 
 export interface RoutingTableEntry {

src/types/view-devices/utils.ts

@@ -22,11 +22,11 @@ export function createViewDevice(
   }
 
   let packetQueueSize: number;
-  let timePerByte: number;
+  let bytesPerSecond: number;
 
   if (isRouter(deviceInfo)) {
     packetQueueSize = deviceInfo.packetQueueSize;
-    timePerByte = deviceInfo.timePerByte;
+    bytesPerSecond = deviceInfo.bytesPerSecond;
   }
   const { id, interfaces, tag } = deviceInfo;
 
@@ -41,7 +41,7 @@ export function createViewDevice(
         tag,
         mask,
         packetQueueSize,
-        timePerByte,
+        bytesPerSecond,
       );
     case DeviceType.Host:
       return new ViewHost(id, viewgraph, ctx, position, interfaces, tag, mask);

src/types/view-devices/vRouter.ts

@@ -21,8 +21,8 @@ export class ViewRouter extends ViewNetworkDevice {
 
   private packetQueueSize: number;
   private packetQueue: PacketQueue;
-  // Time in ms to process a single byte
-  private timePerByte: number;
+  // Number of bytes to process per second
+  private bytesPerSecond: number;
   // Number of bytes processed
   private processingProgress = 0;
 
@@ -42,7 +42,7 @@ export class ViewRouter extends ViewNetworkDevice {
     tag: string,
     mask: IpAddress,
     packetQueueSize: number = ROUTER_CONSTANTS.PACKET_QUEUE_MAX_SIZE,
-    timePerByte: number = ROUTER_CONSTANTS.PROCESSING_SPEED,
+    bytesPerSecond: number = ROUTER_CONSTANTS.PROCESSING_SPEED,
   ) {
     super(
       id,
@@ -56,7 +56,7 @@ export class ViewRouter extends ViewNetworkDevice {
     );
     this.packetQueueSize = packetQueueSize;
     this.packetQueue = new PacketQueue(this.packetQueueSize);
-    this.timePerByte = timePerByte;
+    this.bytesPerSecond = bytesPerSecond;
   }
 
   showInfo(): void {
@@ -90,7 +90,7 @@ export class ViewRouter extends ViewNetworkDevice {
         },
         {
           label: TOOLTIP_KEYS.PROCESSING_SPEED_PARAMETER,
-          initialValue: this.timePerByte,
+          initialValue: this.bytesPerSecond,
           onChange: (newSpeed: number) => {
             this.modifyProcessingSpeed(newSpeed);
           },
@@ -118,8 +118,8 @@ export class ViewRouter extends ViewNetworkDevice {
     this.packetQueueSize = newSize;
   }
 
-  setTimePerByte(newTime: number) {
-    this.timePerByte = newTime;
+  setBytesPerSecond(newTime: number) {
+    this.bytesPerSecond = newTime;
   }
 
   /**
@@ -150,16 +150,16 @@ export class ViewRouter extends ViewNetworkDevice {
    * @param newSpeed - The new processing speed to set, represented as the time per byte.
    *
    * This method updates the internal processing speed of the device by calling
-   * `setTimePerByte` with the provided `newSpeed`. It also ensures that the
+   * `setBytesPerSecond` with the provided `newSpeed`. It also ensures that the
    * corresponding device in the data graph is updated with the same processing speed,
    * but only if the device is an instance of `DataRouter`. If the device is not a
    * `DataRouter`, a warning is logged to the console.
    */
   modifyProcessingSpeed(newSpeed: number): void {
-    this.setTimePerByte(newSpeed);
+    this.setBytesPerSecond(newSpeed);
     this.viewgraph.getDataGraph().modifyDevice(this.id, (device) => {
       if (device instanceof DataRouter) {
-        device.setTimePerByte(newSpeed);
+        device.setBytesPerSecond(newSpeed);
       } else {
         console.warn("Device is not a DataRouter, cannot set time per byte");
       }
@@ -225,13 +225,12 @@ export class ViewRouter extends ViewNetworkDevice {
   }
 
   getPacketsToProcess(timeMs: number): IPv4Packet | null {
-    this.processingProgress += timeMs;
+    this.processingProgress += (this.bytesPerSecond * timeMs) / 1000;
     const packetLength = this.packetQueue.getHead()?.totalLength;
-    const progressNeeded = this.timePerByte * packetLength;
-    if (this.processingProgress < progressNeeded) {
+    if (this.processingProgress < packetLength) {
       return null;
     }
-    this.processingProgress -= progressNeeded;
+    this.processingProgress -= packetLength;
     return this.packetQueue.dequeue();
   }
 

src/utils/constants/router_constants.ts

@@ -1,7 +1,7 @@
 // Router Constants
 export const ROUTER_CONSTANTS = {
-  PACKET_QUEUE_MAX_SIZE: 1024,
-  PROCESSING_SPEED: 8,
+  PACKET_QUEUE_MAX_SIZE: 4096,
+  PROCESSING_SPEED: 1024,
   IP_COL_INDEX: 0,
   MASK_COL_INDEX: 1,
   INTERFACE_COL_INDEX: 2,

src/utils/constants/tooltips_constants.ts

@@ -47,7 +47,7 @@ export const TOOLTIP_KEYS = {
   SWITCH_PARAMETERS: "Switch Parameters",
   HOST_PARAMETERS: "Host Parameters",
   PACKET_QUEUE_SIZE_PARAMETER: "Packet queue size (bytes)",
-  PROCESSING_SPEED_PARAMETER: "Processing speed (ms/byte)",
+  PROCESSING_SPEED_PARAMETER: "Processing speed (bytes/s)",
   REGENERATE: "Regenerate",
   DELETE_EDGE_BUTTON: "Delete Edge",
   CONNECTION: "Connection",