Difference between revisions of "Apex Page"

From CDOT Wiki
Jump to: navigation, search
(→‎Work Breakdown and Progress)
(→‎Enhancement)
Line 21: Line 21:
 
'''Enhancement Result'''
 
'''Enhancement Result'''
  
−
* The frames flow much smoothly due to the transformation of the node chains is updated concurrently and efficiently during rendering instead of being done sequentially.
+
* The frame flow is very smooth due to the transformation of the node chains which are updated concurrently and efficiently during rendering instead of being done sequentially.
  
−
* The program runs faster significantly. To show improved performance of Emperor Engine, we used Performance and Diagnostic tool in Visual Studio on the lab computer. It shows that using thread is 10 times faster than before.
+
* The program runs significantly faster. To show improved performance of the Emperor Engine, we used Performance and Diagnostic tool in Visual Studio on a lab computer. It shows that by using multiple threads, performance has improved 10 times.
  
 
[[File:Node Absolute Calculator Result.jpg]]
 
[[File:Node Absolute Calculator Result.jpg]]
Line 30: Line 30:
  
 
* Class ThreadPool
 
* Class ThreadPool
−
** A class ''ThreadPool'' is created which creates threads at its initialization.
+
** An object of ''ThreadPool'' class is created at its initialization to accept threads in a vector called ''threads''.
−
** The number of threads depends on the number of the computer core system, it can be obtained at the run time through std::thread::hardware_concurrency() in ''ThreadPool'' constructor, and it is stored in a std::vector called ''threads''.
+
** The number of threads depends on the number of the computer core systems, it can be obtained at the run time through std::thread::hardware_concurrency() in ''ThreadPool'' constructor.
−
** The ''threadPool'' is a queue holding jobs which is defined as std::function, and a job is added into ''threadPool ''in ''AddJob'' function.
+
** The ''threadPool'' is a queue holding jobs which are defined as std::function, and a job is added into ''threadPool ''in ''AddJob'' function.
−
** std::mutex and std::condition_variable is used to lock and unlock threads status and to wake threads respectively. In addition to, two bool type variables (quit and stopped) are flag determining to run threads.
+
** std::mutex and std::condition_variable is used to lock and unlock threads status and to wake threads respectively. In addition to, two bool type variables (quit and stopped) are flags to decline a new job while the thread pool is shutting down.
−
** In ''Run'' function, the ''threadPool'' dispatches the job to each thread to be finished one by one until all jobs are done or the program is terminated.
+
** In ''Run'' function, the ''threadPool'' dispatches a job to each thread to be finished one by one until all jobs are done or the program is terminated.
 
** The ''ShutDown'' function wakes all threads up and makes them join to be terminated.
 
** The ''ShutDown'' function wakes all threads up and makes them join to be terminated.
  
 
* To Use the Threads
 
* To Use the Threads
−
** When the NodeManager performs the function updateValues for each active object from the vector activeObjects, jobs(active objects(Node)’ _updateAbs function) are add to the queue threadPool which means an added job is waiting to calculate node’s absolute transformation.
+
** When the NodeManager performs the function updateValues for each active object from the vector activeObjects, jobs(active objects(Node)’ _updateAbs function) are added to the queue threadPool waiting to calculate node’s absolute transformation.
−
** While adding jobs, one thread from thread pool wakes up, and perform the Run function subsequently.
+
** While adding jobs, one slept thread from the thread pool wakes up, and performs the ''Run'' function subsequently.
−
** Before the function updateValues ends, threads are terminated through the ShutDown function of ThreadPool.
+
** Before the function ''updateValues'' ends, threads are terminated through the ShutDown function of ''ThreadPool''.
  
  
Line 46: Line 46:
  
 
* Member 1(Erquan (Ashley) Bi)
 
* Member 1(Erquan (Ashley) Bi)
−
** Work on how many threads need to calculate node absolute transformation on hardware.
+
** Worked on how many threads are needed and how they are being divided and dispatched form the thread pool to a vector of threads for each core to calculate node absolute transformation.
  
 
* Member 2 (Eunju Han)
 
* Member 2 (Eunju Han)
−
** Manager thread running and termination with determined threads.
+
** Managed threads’ running and termination with determined threads and Merged code with Ashley’s work and tested with the client program (Lab8).
  
  
 +
'''Source Code Repository
 +
'''[https://bitbucket.org/Apex_Page/scs_emperor https://bitbucket.org/Apex_Page/scs_emperor]
  
 
<Multi-Thread Resources>
 
<Multi-Thread Resources>
Line 60: Line 62:
  
 
[http://www.cplusplus.com/reference/thread/thread/ std::thread]
 
[http://www.cplusplus.com/reference/thread/thread/ std::thread]
 +
  
  

Revision as of 23:51, 4 December 2015

GAM531 Engine Assignment

Game Engine Apex

Repository

https://bitbucket.org/Apex_Page/

Team Members

  1. Erquan Bi
  2. Eunju Han
  3. Ferenc Botos
  4. eMail All

Enhancement

Title: Multi-threaded Node Absolute Calculator


Enhancement Result

  • The frame flow is very smooth due to the transformation of the node chains which are updated concurrently and efficiently during rendering instead of being done sequentially.
  • The program runs significantly faster. To show improved performance of the Emperor Engine, we used Performance and Diagnostic tool in Visual Studio on a lab computer. It shows that by using multiple threads, performance has improved 10 times.

Node Absolute Calculator Result.jpg

Enhancement Process

  • Class ThreadPool
    • An object of ThreadPool class is created at its initialization to accept threads in a vector called threads.
    • The number of threads depends on the number of the computer core systems, it can be obtained at the run time through std::thread::hardware_concurrency() in ThreadPool constructor.
    • The threadPool is a queue holding jobs which are defined as std::function, and a job is added into threadPool in AddJob function.
    • std::mutex and std::condition_variable is used to lock and unlock threads status and to wake threads respectively. In addition to, two bool type variables (quit and stopped) are flags to decline a new job while the thread pool is shutting down.
    • In Run function, the threadPool dispatches a job to each thread to be finished one by one until all jobs are done or the program is terminated.
    • The ShutDown function wakes all threads up and makes them join to be terminated.
  • To Use the Threads
    • When the NodeManager performs the function updateValues for each active object from the vector activeObjects, jobs(active objects(Node)’ _updateAbs function) are added to the queue threadPool waiting to calculate node’s absolute transformation.
    • While adding jobs, one slept thread from the thread pool wakes up, and performs the Run function subsequently.
    • Before the function updateValues ends, threads are terminated through the ShutDown function of ThreadPool.


Work Load Division

  • Member 1(Erquan (Ashley) Bi)
    • Worked on how many threads are needed and how they are being divided and dispatched form the thread pool to a vector of threads for each core to calculate node absolute transformation.
  • Member 2 (Eunju Han)
    • Managed threads’ running and termination with determined threads and Merged code with Ashley’s work and tested with the client program (Lab8).


Source Code Repository https://bitbucket.org/Apex_Page/scs_emperor

<Multi-Thread Resources>

Multi-Threading of OOP345

C++ Multithreading Tutorial

std::thread



Sphere Collision or View Frustum Culling
<Sphere Collision Resources>
SIMPLE SPHERE-SPHERE COLLISION DETECTION AND COLLISION RESPONSE

3D Collision detection (C++) - Miguel Casillas

Pool Hall Lessons: Fast, Accurate Collision Detection Between Circles or Spheres

What is a good algorithm to detect collision between moving spheres?

Work Breakdown and Progress


BitBucket Fetching a remote reference
https://help.github.com/articles/fetching-a-remote/


Lab Workload Plan

  • Anybody: lab1(Eunju)
  • Ashley: lab2,5,8
  • Eunju: lab3,6,9
  • Frank: lab4,7,10

Lab completed

  • Ashley: Lab2, 4, 5, 7, 10
  • Eunju: Lab1, 3, 6, 8, 9


Tasks Assigned Completed Status Due date
Lab 1 Eunju Yes 2015-09-25 2015-09-25
Lab 2 Ashley Yes 2015-10-02 2015-10-02
Lab 3 Eunju Yes 2015-10-17 2015-10-09
Submit Proposal / Research Document Group YES Friday October 16th, 2015
Lab 4 Frank Ashley Yes 2015-11-03 2015-10-16
Lab 5 Ashley Yes 2015-11-03 2015-11-03
Lab 6 Eunju Yes 2015-11-07(1 min late because of merging issue) 2015-11-06
Lab 7 Frank Ashley Yes 2015-11-13 2015-11-13
Lab 8 Ashley Eunju Yes 2015-11-20 2015-11-20
Lab 9 Eunju Yes 2015-11-26 2015-11-27
Lab 10 Frank Ashley NO 2015-12-04
OpenGL Lab7 Ashley NO 2015-11-13
OpenGL Lab8 Eunju NO 2015-11-20
OpenGL Lab9 Eunju NO 2015-11-27
OpenGL Lab10 Ashley NO 2015-12-04
Submit Engine Enhancement Group YES Friday November 27th, 2015
Submit Project (completed engine) Group NO Thursday December 10th, 2015
Retrieved from "https://wiki.cdot.senecapolytechnic.ca/w/index.php?title=Apex_Page&oldid=113519"