Naming conventions

Author: sami-hatna66

external/Actor.cpp

@@ -91,7 +91,7 @@ Actor::checkAtDestination(sycl::float4 destination,
     // Destinations are defined as rectangular regions
     if (pos[0] >= destination[0] && pos[0] <= destination[2] &&
         pos[1] >= destination[1] && pos[1] <= destination[3]) {
-        if (destinationIndex >= PATHALLOCATIONSIZE - 1 ||
+        if (destinationIndex >= PATH_ALLOCATION_SIZE - 1 ||
             destinationIndex >= pathSize - 1) {
             this->setAtDestination(true);
         } else {

external/ParseInputFile.cpp

@@ -76,10 +76,10 @@ void validateParameters(rapidjson::Document &jsonDoc) {
 }
 
 void parseInputFile(std::string filename, std::vector<Actor> &actors,
-                    Room &room, std::vector<Path> &paths, int &WIDTH,
-                    int &HEIGHT, int &SCALE, int &DELAY,
-                    std::array<int, 3> &BGCOLOR, std::array<int, 3> &WALLCOLOR,
-                    bool &HEATMAPENABLED) {
+                    Room &room, std::vector<Path> &paths, int &width,
+                    int &height, int &scale, int &delay,
+                    std::array<int, 3> &bgColor, std::array<int, 3> &wallColor,
+                    bool &heatmapEnabled) {
     std::ifstream jsonFile(filename);
     if (!jsonFile.is_open()) {
         throw JSONException("Error opening file " + filename);
@@ -95,16 +95,16 @@ void parseInputFile(std::string filename, std::vector<Actor> &actors,
 
     // Config
     auto &config = jsonDoc["config"];
-    WIDTH = config["width"].GetInt();
-    HEIGHT = config["height"].GetInt();
-    SCALE = config["scale"].GetInt();
-    DELAY = config["delay"].GetInt();
-    WALLCOLOR = {config["wallColor"][0].GetInt(),
+    width = config["width"].GetInt();
+    height = config["height"].GetInt();
+    scale = config["scale"].GetInt();
+    delay = config["delay"].GetInt();
+    wallColor = {config["wallColor"][0].GetInt(),
                  config["wallColor"][1].GetInt(),
                  config["wallColor"][2].GetInt()};
-    BGCOLOR = {config["bgColor"][0].GetInt(), config["bgColor"][1].GetInt(),
+    bgColor = {config["bgColor"][0].GetInt(), config["bgColor"][1].GetInt(),
                config["bgColor"][2].GetInt()};
-    HEATMAPENABLED = config["heatmapEnabled"].GetBool();
+    heatmapEnabled = config["heatmapEnabled"].GetBool();
 
     // Room
     auto jsonWalls = jsonDoc["room"]["walls"].GetArray();
@@ -120,8 +120,8 @@ void parseInputFile(std::string filename, std::vector<Actor> &actors,
     for (auto &p : jsonPaths) {
         int id = p["id"].GetInt();
         auto jsonCheckpoints = p["checkpoints"].GetArray();
-        std::array<sycl::float4, PATHALLOCATIONSIZE> checkpoints;
-        if (jsonCheckpoints.Size() > PATHALLOCATIONSIZE) {
+        std::array<sycl::float4, PATH_ALLOCATION_SIZE> checkpoints;
+        if (jsonCheckpoints.Size() > PATH_ALLOCATION_SIZE) {
             throw JSONException(
                 "Path Size exceeds amount allocated in memory\nEither reduce "
                 "path size or increase PATHALLOCATIONSIZE in 'Path.hpp'");

external/ParseInputFile.hpp

@@ -47,9 +47,9 @@ class JSONException : public std::runtime_error {
 void validateParameters(rapidjson::Document &jsonDoc);
 
 void parseInputFile(std::string filename, std::vector<Actor> &actors,
-                    Room &room, std::vector<Path> &paths, int &WIDTH,
-                    int &HEIGHT, int &SCALE, int &DELAY,
-                    std::array<int, 3> &BGCOLOR, std::array<int, 3> &WALLCOLOR,
-                    bool &HEATMAPENABLED);
+                    Room &room, std::vector<Path> &paths, int &width,
+                    int &height, int &scale, int &delay,
+                    std::array<int, 3> &bgColor, std::array<int, 3> &wallColor,
+                    bool &heatmapEnabled);
 
 #endif

external/Path.cpp

@@ -27,13 +27,13 @@
 
 Path::Path(
     int pId,
-    std::array<sycl::float4, PATHALLOCATIONSIZE> pCheckpoints,
+    std::array<sycl::float4, PATH_ALLOCATION_SIZE> pCheckpoints,
     int pPathSize)
     : id(pId), checkpoints(pCheckpoints), pathSize(pPathSize) {}
 
 SYCL_EXTERNAL int Path::getId() const { return id; }
 
-SYCL_EXTERNAL std::array<sycl::float4, PATHALLOCATIONSIZE>
+SYCL_EXTERNAL std::array<sycl::float4, PATH_ALLOCATION_SIZE>
 Path::getCheckpoints() const {
     return checkpoints;
 }
@@ -43,7 +43,7 @@ SYCL_EXTERNAL int Path::getPathSize() const { return pathSize; }
 void Path::setId(int newId) { id = newId; }
 
 void Path::setCheckpoints(
-    std::array<sycl::float4, PATHALLOCATIONSIZE>
+    std::array<sycl::float4, PATH_ALLOCATION_SIZE>
         newCheckpoints) {
     checkpoints = newCheckpoints;
 }

external/Path.hpp

@@ -33,28 +33,28 @@
 // Constant denoting the size of the array used to store paths
 // SYCL kernels can't use dynamic vectors, so paths are stored in
 // a fixed-size array, so the path size can't exceed this constant
-const int PATHALLOCATIONSIZE = 10;
+const int PATH_ALLOCATION_SIZE = 10;
 
 class Path {
   private:
-    std::array<sycl::float4, PATHALLOCATIONSIZE> checkpoints;
+    std::array<sycl::float4, PATH_ALLOCATION_SIZE> checkpoints;
     int id;
     int pathSize;
 
   public:
     Path(int pId,
-         std::array<sycl::float4, PATHALLOCATIONSIZE>
+         std::array<sycl::float4, PATH_ALLOCATION_SIZE>
              pCheckpoints,
          int pPathSize);
 
     SYCL_EXTERNAL int getId() const;
-    SYCL_EXTERNAL std::array<sycl::float4, PATHALLOCATIONSIZE>
+    SYCL_EXTERNAL std::array<sycl::float4, PATH_ALLOCATION_SIZE>
     getCheckpoints() const;
     SYCL_EXTERNAL int getPathSize() const;
 
     void setId(int newId);
     void
-    setCheckpoints(std::array<sycl::float4, PATHALLOCATIONSIZE>
+    setCheckpoints(std::array<sycl::float4, PATH_ALLOCATION_SIZE>
                        newCheckpoints);
 };
 

src/main.cpp

@@ -45,17 +45,15 @@
 #include "Stats.hpp"
 #endif
 
-uint GLOBALSEED;
-
-void init(int &WIDTH, int &HEIGHT, int &SCALE, int &DELAY,
-          std::array<int, 3> &BGCOLOR, std::array<int, 3> &WALLCOLOR,
-          bool &HEATMAPENABLED, std::vector<Actor> &actors, Room &room,
+void init(int &width, int &height, int &scale, int &delay,
+          std::array<int, 3> &bgColor, std::array<int, 3> &wallColor,
+          bool &heatmapEnabled, std::vector<Actor> &actors, Room &room,
           std::vector<Path> &paths, int argc, char **argv) {
     // Read from input file path JSON
     if (argc == 2) {
         std::string inputPath = argv[1];
-        parseInputFile(inputPath, actors, room, paths, WIDTH, HEIGHT, SCALE,
-                       DELAY, BGCOLOR, WALLCOLOR, HEATMAPENABLED);
+        parseInputFile(inputPath, actors, room, paths, width, height, scale,
+                       delay, bgColor, wallColor, heatmapEnabled);
     } else if (argc < 2) {
         throw std::invalid_argument(
             "Input configuration file must be supplied");
@@ -73,12 +71,12 @@ void init(int &WIDTH, int &HEIGHT, int &SCALE, int &DELAY,
 }
 
 #ifndef PROFILING_MODE
-void initSDL(int WIDTH, int HEIGHT, int SCALE, SDL_Window *&win,
+void initSDL(int width, int height, int scale, SDL_Window *&win,
              SDL_Renderer *&render) {
     SDL_Init(SDL_INIT_VIDEO);
     win = SDL_CreateWindow("SYCL Crowd Simulation", SDL_WINDOWPOS_UNDEFINED,
-                           SDL_WINDOWPOS_UNDEFINED, WIDTH * SCALE,
-                           HEIGHT * SCALE, SDL_WINDOW_SHOWN);
+                           SDL_WINDOWPOS_UNDEFINED, width * scale,
+                           height * scale, SDL_WINDOW_SHOWN);
     render = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED);
 }
 
@@ -96,29 +94,29 @@ void drawCircle(SDL_Renderer *&render, SDL_Point center, int radius,
     }
 }
 
-void draw(int SCALE, std::array<int, 3> BGCOLOR, std::array<int, 3> WALLCOLOR,
+void draw(int scale, std::array<int, 3> bgColor, std::array<int, 3> wallColor,
           SDL_Renderer *&render,
           sycl::host_accessor<Actor, 1, sycl::access::mode::read> actors,
           Room room) {
-    SDL_SetRenderDrawColor(render, BGCOLOR[0], BGCOLOR[1], BGCOLOR[2], 255);
+    SDL_SetRenderDrawColor(render, bgColor[0], bgColor[1], bgColor[2], 255);
     SDL_RenderClear(render);
 
     for (int i = 0; i < actors.size(); i++) {
         auto actor = actors[i];
-        SDL_Point pos = {int(actor.getPos()[0] * SCALE),
-                         int(actor.getPos()[1] * SCALE)};
+        SDL_Point pos = {int(actor.getPos()[0] * scale),
+                         int(actor.getPos()[1] * scale)};
         SDL_Color actorColor = {Uint8(actor.getColor()[0]),
                                 Uint8(actor.getColor()[1]),
                                 Uint8(actor.getColor()[2]), 255};
-        drawCircle(render, pos, actor.getRadius() * SCALE, actorColor);
+        drawCircle(render, pos, actor.getRadius() * scale, actorColor);
     }
 
-    SDL_SetRenderDrawColor(render, WALLCOLOR[0], WALLCOLOR[1], WALLCOLOR[2],
+    SDL_SetRenderDrawColor(render, wallColor[0], wallColor[1], wallColor[2],
                            255);
     auto walls = room.getWalls();
     for (auto wall : walls) {
-        SDL_RenderDrawLine(render, wall[0][0] * SCALE, wall[0][1] * SCALE,
-                           wall[1][0] * SCALE, wall[1][1] * SCALE);
+        SDL_RenderDrawLine(render, wall[0][0] * scale, wall[0][1] * scale,
+                           wall[1][0] * scale, wall[1][1] * scale);
     }
 
     SDL_RenderPresent(render);
@@ -183,14 +181,14 @@ void updateBBox(sycl::queue &myQueue, sycl::buffer<Actor> &actorBuf) {
 }
 
 int main(int argc, char *argv[]) {
-    int WIDTH;  // metres
-    int HEIGHT; // metres
-    int SCALE;
-    int DELAY;
-    bool HEATMAPENABLED;
+    int width;  // metres
+    int height; // metres
+    int scale;
+    int delay;
+    bool heatmapEnabled;
 
-    std::array<int, 3> BGCOLOR;
-    std::array<int, 3> WALLCOLOR;
+    std::array<int, 3> bgColor;
+    std::array<int, 3> wallColor;
 
     std::vector<Actor> actors;
     Room room = Room({});
@@ -204,13 +202,13 @@ int main(int argc, char *argv[]) {
 
     sycl::queue myQueue{sycl::gpu_selector(), asyncHandler};
 
-    init(WIDTH, HEIGHT, SCALE, DELAY, BGCOLOR, WALLCOLOR, HEATMAPENABLED,
+    init(width, height, scale, delay, bgColor, wallColor, heatmapEnabled,
          actors, room, paths, argc, argv);
 
 #ifndef PROFILING_MODE
     SDL_Window *win;
     SDL_Renderer *render;
-    initSDL(WIDTH, HEIGHT, SCALE, win, render);
+    initSDL(width, height, scale, win, render);
 #endif
 
     // Buffer creation
@@ -221,7 +219,7 @@ int main(int argc, char *argv[]) {
     wallsBuf.set_final_data(nullptr);
     auto pathsBuf = sycl::buffer<Path>(paths.data(), paths.size());
     pathsBuf.set_final_data(nullptr);
-    auto heatmapEnableBuf = sycl::buffer<bool>(&HEATMAPENABLED, 1);
+    auto heatmapEnableBuf = sycl::buffer<bool>(&heatmapEnabled, 1);
 
     int delayCounter = 0;
     int updateBBoxCounter = 0;
@@ -260,7 +258,7 @@ int main(int argc, char *argv[]) {
 #endif
 
         if (!isPause) {
-            if (delayCounter >= DELAY) {
+            if (delayCounter >= delay) {
                 delayCounter = 0;
 
 #ifdef STATS
@@ -294,7 +292,7 @@ int main(int argc, char *argv[]) {
                     actorHostAcc(actorBuf);
 
 #ifndef PROFILING_MODE
-                draw(SCALE, BGCOLOR, WALLCOLOR, render, actorHostAcc, room);
+                draw(scale, bgColor, wallColor, render, actorHostAcc, room);
 #endif
 
                 updateBBoxCounter--;