Merge branch 'phase4' into 'main'

Phase4 Code Review

See merge request sami.hatna/crowd-simulation!5

Author: Sami Hatna

CMakeLists.txt

@@ -8,13 +8,44 @@ project(crowd-simulation)
 set(CMAKE_C_COMPILER /home/sami/sycl_workspace/llvm/build/bin/clang)
 set(CMAKE_CXX_COMPILER /home/sami/sycl_workspace/llvm/build/bin/clang++)
 
-find_package(SDL2 REQUIRED)
-include_directories(${SDL2_INCLUDE_DIRS})
+OPTION(PROFILING_MODE "Enable profiling" off)
+if(PROFILING_MODE)
+    add_definitions(-DPROFILING_MODE)
+else()
+    find_package(SDL2 REQUIRED)
+    include_directories(${SDL2_INCLUDE_DIRS})
+endif()
+
+OPTION(STATS "Run in stats mode" off)
+if (STATS)
+    add_definitions(-DSTATS)
+endif()
+
+set(SYCL_BACKEND "SYCL_BACKEND" CACHE STRING "Backend chosen by the user at CMake configure time")
+set_property(CACHE SYCL_BACKEND PROPERTY STRINGS spir cuda hip)
+
+if(SYCL_BACKEND STREQUAL hip)
+    SET(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} -fsycl -fsycl-targets=amdgcn-amd-amdhsa")
+elseif(SYCL_BACKEND STREQUAL cuda)
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsycl -fsycl-targets=nvptx64-nvidia-cuda")
+else()
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsycl -fsycl-targets=spir64")
+endif()
+
+find_package(Python QUIET)
+if(Python_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/scripts/InputFileGenerator.py")
+    execute_process(COMMAND ${Python_EXECUTABLE} ../scripts/InputFileGenerator.py)
+else()
+    message(WARNING "Unable to generate input configuration files")
+endif()
 
 add_executable(crowdsim src/main.cpp)
-SET(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} -fsycl -fsycl-targets=spir64-gen")
 
 add_subdirectory(external)
 
-target_link_libraries(crowdsim PUBLIC ${SDL2_LIBRARIES} external) 
+if (PROFILING_MODE)
+    target_link_libraries(crowdsim PUBLIC external) 
+else()
+    target_link_libraries(crowdsim PUBLIC ${SDL2_LIBRARIES} external)
+endif()
 target_include_directories(crowdsim PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/external")

external/Actor.cpp

@@ -6,8 +6,7 @@ Actor::Actor(vecType pPos, vecType pVelocity, float pDesiredSpeed, int pPathId,
     : pos(pPos), velocity(pVelocity), desiredSpeed(pDesiredSpeed),
       pathId(pPathId), mass(pMass), radius(pRadius),
       atDestination(pAtDestination), color(pColor),
-      heatmapEnabled(pHeatmapEnabled), variation({0, 0}), destinationIndex(0),
-      bBox({0, 0}) {}
+      heatmapEnabled(pHeatmapEnabled), destinationIndex(0), bBox({0, 0}) {}
 
 SYCL_EXTERNAL vecType Actor::getPos() const { return pos; }
 
@@ -21,8 +20,6 @@ SYCL_EXTERNAL int Actor::getDestinationIndex() const {
     return destinationIndex;
 }
 
-SYCL_EXTERNAL vecType Actor::getVariation() const { return variation; }
-
 SYCL_EXTERNAL float Actor::getMass() const { return mass; }
 
 SYCL_EXTERNAL float Actor::getRadius() const { return radius; }
@@ -37,6 +34,8 @@ SYCL_EXTERNAL std::array<int, 2> Actor::getBBox() const { return bBox; }
 
 SYCL_EXTERNAL uint Actor::getSeed() const { return seed; }
 
+SYCL_EXTERNAL float Actor::getForce() const { return force; }
+
 SYCL_EXTERNAL void Actor::setPos(vecType newPos) { pos = newPos; }
 
 SYCL_EXTERNAL void Actor::setVelocity(vecType newVelocity) {
@@ -47,10 +46,6 @@ SYCL_EXTERNAL void Actor::setDesiredSpeed(float newDesiredSpeed) {
     desiredSpeed = newDesiredSpeed;
 }
 
-SYCL_EXTERNAL void Actor::setVariation(vecType newVariation) {
-    variation = newVariation;
-}
-
 SYCL_EXTERNAL void Actor::setAtDestination(bool param) {
     atDestination = param;
 }
@@ -65,20 +60,13 @@ SYCL_EXTERNAL void Actor::setBBox(std::array<int, 2> newBBox) {
 
 SYCL_EXTERNAL void Actor::setSeed(uint newSeed) { seed = newSeed; }
 
-SYCL_EXTERNAL void Actor::refreshVariations() {
-    // Previous RNG output is used as next seed
-    seed = randXorShift(seed);
-    float randX = (float(seed) * (2.0f / 4294967296.0f)) - 1.0f;
-    seed = randXorShift(seed);
-    float randY = (float(seed) * (2.0f / 4294967296.0f)) - 1.0f;
-    this->setVariation({randX, randY});
-}
+SYCL_EXTERNAL void Actor::setForce(float newForce) { force = newForce; }
 
-SYCL_EXTERNAL void Actor::checkAtDestination(std::array<vecType, 4> destination,
+SYCL_EXTERNAL void Actor::checkAtDestination(std::array<vecType, 2> destination,
                                              int pathSize) {
     // Destinations are defined as rectangular regions
-    if (pos[0] >= destination[0][0] && pos[0] <= destination[2][0] &&
-        pos[1] >= destination[0][1] && pos[1] <= destination[2][1]) {
+    if (pos[0] >= destination[0][0] && pos[0] <= destination[1][0] &&
+        pos[1] >= destination[0][1] && pos[1] <= destination[1][1]) {
         if (destinationIndex >= PATHALLOCATIONSIZE - 1 ||
             destinationIndex >= pathSize - 1) {
             this->setAtDestination(true);

external/Actor.hpp

@@ -2,8 +2,8 @@
 #define Actor_hpp
 
 #include "Path.hpp"
-#include "VectorMaths.hpp"
 #include "RandomNumber.hpp"
+#include "VectorMaths.hpp"
 #include <array>
 #include <iostream>
 #include <random>
@@ -17,14 +17,14 @@ class Actor {
     float desiredSpeed;
     int pathId;
     int destinationIndex;
-    vecType variation;
     float mass;
     float radius;
     bool atDestination;
     std::array<int, 3> color;
     bool heatmapEnabled;
     std::array<int, 2> bBox;
     uint seed;
+    float force;
 
   public:
     Actor(vecType pPos, vecType pVelocity, float pdesiredSpeed, int pPathId,
@@ -36,27 +36,25 @@ class Actor {
     SYCL_EXTERNAL float getDesiredSpeed() const;
     SYCL_EXTERNAL int getPathId() const;
     SYCL_EXTERNAL int getDestinationIndex() const;
-    SYCL_EXTERNAL vecType getVariation() const;
     SYCL_EXTERNAL float getMass() const;
     SYCL_EXTERNAL float getRadius() const;
     SYCL_EXTERNAL bool getAtDestination() const;
     SYCL_EXTERNAL std::array<int, 3> getColor() const;
     SYCL_EXTERNAL bool getHeatmapEnabled() const;
     SYCL_EXTERNAL std::array<int, 2> getBBox() const;
     SYCL_EXTERNAL uint getSeed() const;
+    SYCL_EXTERNAL float getForce() const;
 
     SYCL_EXTERNAL void setPos(vecType newPos);
     SYCL_EXTERNAL void setVelocity(vecType newVelocity);
     SYCL_EXTERNAL void setDesiredSpeed(float newDesiredSpeed);
-    SYCL_EXTERNAL void setVariation(vecType newVariation);
     SYCL_EXTERNAL void setAtDestination(bool param);
     SYCL_EXTERNAL void setColor(std::array<int, 3> newColor);
     SYCL_EXTERNAL void setBBox(std::array<int, 2> newBBox);
     SYCL_EXTERNAL void setSeed(uint newSeed);
+    SYCL_EXTERNAL void setForce(float newForce);
 
-    SYCL_EXTERNAL void refreshVariations();
-
-    SYCL_EXTERNAL void checkAtDestination(std::array<vecType, 4> destination,
+    SYCL_EXTERNAL void checkAtDestination(std::array<vecType, 2> destination,
                                           int pathSize);
 };
 

external/CMakeLists.txt

@@ -1 +1,11 @@
-add_library(external Actor.cpp Room.cpp Path.cpp MathHelper.cpp DifferentialEq.cpp VectorMaths.cpp Heatmap.cpp ParseInputFile.cpp RandomNumber.cpp)
+add_library(external Actor.cpp 
+                     Room.cpp 
+                     Path.cpp 
+                     MathHelper.cpp 
+                     DifferentialEq.cpp 
+                     VectorMaths.cpp 
+                     Heatmap.cpp 
+                     ParseInputFile.cpp 
+                     RandomNumber.cpp 
+                     Stats.cpp
+            )

external/DifferentialEq.cpp

@@ -4,24 +4,30 @@ SYCL_EXTERNAL void differentialEq(
     int actorIndex,
     sycl::accessor<Actor, 1, sycl::access::mode::read_write> actors,
     sycl::accessor<std::array<vecType, 2>, 1, sycl::access::mode::read> walls,
-    sycl::accessor<Path, 1, sycl::access::mode::read> paths, sycl::stream out) {
+    sycl::accessor<Path, 1, sycl::access::mode::read> paths) {
     Actor *currentActor = &actors[actorIndex];
 
     vecType pos = currentActor->getPos();
 
     // Calculate personal impulse
     float mi = currentActor->getMass();
     float v0i = currentActor->getDesiredSpeed();
-    std::array<vecType, 4> destination =
+    std::array<vecType, 2> destination =
         paths[currentActor->getPathId()]
             .getCheckpoints()[currentActor->getDestinationIndex()];
 
     // Find direction vector to nearest point in destination region
     std::pair<float, vecType> minRegionDistance;
+    std::array<vecType, 4> destinationRect = {
+        destination[0],
+        {destination[1][0], destination[0][1]},
+        destination[1],
+        {destination[0][0], destination[1][1]}};
     for (int x = 0; x < 4; x++) {
         int endIndex = x == 3 ? 0 : x + 1;
-        auto dniw = getDistanceAndNiw(currentActor->getPos(),
-                                      {destination[x], destination[endIndex]});
+        auto dniw =
+            getDistanceAndNiw(currentActor->getPos(),
+                              {destinationRect[x], destinationRect[endIndex]});
         if (dniw.first < minRegionDistance.first ||
             minRegionDistance.first == 0) {
             minRegionDistance = dniw;
@@ -93,8 +99,18 @@ SYCL_EXTERNAL void differentialEq(
 
     vecType forceSum = personalImpulse + peopleForces + wallForces;
 
+#ifdef STATS
+    if (!currentActor->getAtDestination()) {
+        currentActor->setForce(magnitude(forceSum));
+    }
+#endif
+
     // Apply random force variations
-    forceSum += currentActor->getVariation();
+    float seed = currentActor->getSeed();
+    float randX = rngMinusOneToOne(seed);
+    float randY = rngMinusOneToOne(randXorShift(seed));
+    forceSum += {randX, randY};
+    currentActor->setSeed(randXorShift(seed));
 
     // Color actor according to heatmap
     if (currentActor->getHeatmapEnabled()) {
@@ -111,6 +127,7 @@ SYCL_EXTERNAL void differentialEq(
         currentActor->setColor({int(color[0]), int(color[1]), int(color[2])});
     }
 
+    // Perform integration
     vecType acceleration = forceSum / mi;
     currentActor->setVelocity(vi + acceleration * TIMESTEP);
     currentActor->setPos(pos + currentActor->getVelocity() * TIMESTEP);

external/DifferentialEq.hpp

@@ -12,7 +12,7 @@
 #include <sycl/sycl.hpp>
 
 // Constant for scaling inter-actor repulsive force
-constexpr float PEOPLEAi = 500;
+constexpr float PEOPLEAi = 800;
 // Constant for scaling actor-wall repulsive force
 constexpr float WALLAi = 1300;
 // Reproduces distance kept at normal desired velocities
@@ -31,6 +31,6 @@ SYCL_EXTERNAL void differentialEq(
     int actorIndex,
     sycl::accessor<Actor, 1, sycl::access::mode::read_write> actors,
     sycl::accessor<std::array<vecType, 2>, 1, sycl::access::mode::read> walls,
-    sycl::accessor<Path, 1, sycl::access::mode::read> paths, sycl::stream out);
+    sycl::accessor<Path, 1, sycl::access::mode::read> paths);
 
 #endif

external/Heatmap.cpp

@@ -1,5 +1,6 @@
 #include "Heatmap.hpp"
 
+// Required because SDL only takes RGB colors
 SYCL_EXTERNAL std::array<float, 3> HSVtoRGB(float h, float s, float v) {
     float c = v * s;
     double scaledH = sycl::fmod(h / 60.0, 6.0);

external/MathHelper.cpp

@@ -17,6 +17,8 @@ SYCL_EXTERNAL float magnitude(vecType inp) {
     return sycl::sqrt((inp[0] * inp[0]) + (inp[1] * inp[1]));
 }
 
+// Fast inverse square root optimisation
+// https://en.wikipedia.org/wiki/Fast_inverse_square_root
 SYCL_EXTERNAL float inverseMagnitude(vecType inp) {
     return sycl::rsqrt((inp[0] * inp[0]) + (inp[1] * inp[1]));
 }
@@ -33,6 +35,7 @@ SYCL_EXTERNAL vecType normalize(vecType inp) {
     return inp * inverseMagnitude(inp);
 }
 
+// Returns pair of distance to line and normalised direction from wall to point
 SYCL_EXTERNAL std::pair<float, vecType>
 getDistanceAndNiw(vecType point, std::array<vecType, 2> wall) {
     vecType AB = getDirectionVector(wall[0], wall[1]);

external/ParseInputFile.cpp

@@ -1,5 +1,6 @@
 #include "ParseInputFile.hpp"
 
+// Checks that input json file contains required members
 void validateParameters(rapidjson::Document &jsonDoc) {
     std::string missingParameters = "";
 
@@ -16,7 +17,8 @@ void validateParameters(rapidjson::Document &jsonDoc) {
         throw JSONException("Missing these parameters: " + missingParameters);
     } else {
         auto &config = jsonDoc["config"];
-        auto configParams = {"width", "height", "scale", "delay"};
+        auto configParams = {"width", "height",    "scale",
+                             "delay", "wallColor", "bgColor"};
         for (auto p : configParams) {
             if (!config.HasMember(p))
                 missingParameters += std::string(p) + " ";
@@ -51,7 +53,9 @@ 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) {
+                    int &HEIGHT, int &SCALE, int &DELAY,
+                    std::array<int, 3> &BGCOLOR,
+                    std::array<int, 3> &WALLCOLOR) {
     std::ifstream jsonFile(filename);
     if (!jsonFile.is_open()) {
         throw JSONException("Error opening file " + filename);
@@ -71,6 +75,11 @@ void parseInputFile(std::string filename, std::vector<Actor> &actors,
     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(),
+               config["bgColor"][2].GetInt()};
 
     // Room
     auto jsonWalls = jsonDoc["room"]["walls"].GetArray();
@@ -86,18 +95,18 @@ 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<std::array<vecType, 4>, PATHALLOCATIONSIZE> checkpoints;
+        std::array<std::array<vecType, 2>, PATHALLOCATIONSIZE> checkpoints;
         if (jsonCheckpoints.Size() > PATHALLOCATIONSIZE) {
             throw JSONException(
                 "Path Size exceeds amount allocated in memory\nEither reduce "
                 "path size or increase PATHALLOCATIONSIZE in 'Path.hpp'");
         }
         for (int i = 0; i < jsonCheckpoints.Size(); i++) {
-            std::array<vecType, 4> region;
-            for (int j = 0; j < 4; j++) {
-                region[j] = vecType({jsonCheckpoints[i][j][0].GetFloat(),
-                                     jsonCheckpoints[i][j][1].GetFloat()});
-            }
+            std::array<vecType, 2> region;
+            region[0] = vecType({jsonCheckpoints[i][0][0].GetFloat(),
+                                 jsonCheckpoints[i][0][1].GetFloat()});
+            region[1] = vecType({jsonCheckpoints[i][1][0].GetFloat(),
+                                 jsonCheckpoints[i][1][1].GetFloat()});
             checkpoints[i] = region;
         }
         int pathSize = jsonCheckpoints.Size();

external/ParseInputFile.hpp

@@ -24,6 +24,7 @@ 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);
+                    int &HEIGHT, int &SCALE, int &DELAY,
+                    std::array<int, 3> &BGCOLOR, std::array<int, 3> &WALLCOLOR);
 
 #endif