passing vector elements in a function [closed] - c++

Question

Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 3 years ago.
Improve this question
I am new to multithreading so any suggestions will be very useful! I am implementing a multithreading program according to the following requirements:
The user inputs a list of integers as a vector. Each vector element N represents a cell.
The vector elements are passed to a threading function, from which the total cells at a certain time are calculated
The lifetime of the cells ( 0.1 + N % 8 seconds) is calculated. At half their lifetime, they breed a number (( N – N % 8 ) / 8 ) of child cells.
The child cells live the same amount as their parents, but die without breeding when their lifetime is over.
A cell monitor is started before the first genesis cell thread is created. The monitor will print out the number of existing live cells every second, so as to monitor how many cells are live.
A main function awaits input from user. vector inputs are given, it will start the
monitor thread and then start the genesis cells threads.

Answer 1

The code in the question has given me some uncertainties on how the reproduction is supposed to be performed, but I have made the following assumptions:
((N - N % 8) / 8) refers to how many child cells are produced by each parent, N, when it reaches half its lifetime, this is not what the code in question implies
The child cells live the same amount of time as their parents, starting from when they are created - so they outlive their parents instead of dying at the same time, this is again not what the code in question does
The scheme I would employ to accomplish the outlined simulation would be to have one thread which controls a time variable, either the main thread or a thread created specifically for the purpose. This thread will increment the time as needed, but will wait for all threads to check if their cell has died or needs to reproduce and perform necessary operations between increments. The example below demonstrates this approach.
I find this is a little bit easier and perhaps clearer when using std::atomic variables to store the number of living cells, the simulation time, the number of threads needing to be checked, etc. When using an atomic variable, the necessary memory fencing is performed for any increment or decrement without needing a std::mutex or other explicit synchronization. Additionally, it may be better to implement a class for the cells, that way they can store their own lifetime, if they are alive still, whether they are a child or a parent, whether they have children, etc.
Example
#include <iostream>
#include <thread>
#include <atomic>
#include <vector>
#include <mutex>
class Cell {
public:
Cell(int x, bool child = false) {
lifetime = (0.1 + x % 8);
n = x;
is_child = child;
alive = true;
has_children = false;
}
int lifetime;
int n;
bool is_child;
bool has_children;
bool alive;
};
std::mutex mtx; // This will be used to synchronize threads.push_back()
// when creating children cells
std::vector<Cell> cells;
std::vector<std::thread> threads;
std::atomic<int> t; // The simulation time
std::atomic<int> living; // The number of living cells
std::atomic<int> check; // This will be used to ensure every thread goes through the
// necessary checks every time step
void thread_function(Cell cell) {
int prev = t;
while (living > 0) {
while (prev == t) {if (living == 0) return;}
prev = (int)t;
if (!cell.has_children && !cell.is_child && t > cell.lifetime / 2.0) {
cell.has_children = true;
// Create children and send them to new threads
for (int ii = 0; ii < ((cell.n - cell.n % 8) / 8); ii ++) {
living ++;
Cell c(ii, true); // Create a new cell which will die
c.lifetime = cell.lifetime + t; // {lifetime} seconds from now
mtx.lock();
threads.push_back(std::thread(thread_function, c));
mtx.unlock();
}
}
if (cell.alive && t >= cell.lifetime) {
cell.alive = false;
living --;
}
check --;
}
}
int main(int argn, char** argv) {
living = argn - 1;
if (argn > 1) {
for (int ii = 1; ii < argn; ii ++) {
cells.push_back(Cell(atoi(argv[ii])));
threads.push_back(std::thread(thread_function, cells[ii-1]));
}
}
t = 0;
while (living > 0) {
std::cout << "Total Cells: "+std::to_string(living)+" [ "+std::to_string(t)+
" s ]\n" << std::flush;
check = threads.size();
t ++;
while (check > 0) {
if (living == 0) break;
}
}
std::cout << "Total Cells: "+std::to_string(living)+" [ "+std::to_string(t)+
" s ]\n" << std::flush;
for (int ii = 0; ii < threads.size(); ii ++) {
threads[ii].join();
}
}
./cells 1 2 3 4 5 6 7
Total Cells: 7 [ 0 s ]
Total Cells: 6 [ 1 s ]
Total Cells: 5 [ 2 s ]
Total Cells: 4 [ 3 s ]
Total Cells: 3 [ 4 s ]
Total Cells: 2 [ 5 s ]
Total Cells: 1 [ 6 s ]
Total Cells: 0 [ 7 s ]
./cells 21 12 6 7 1 17 25
Total Cells: 7 [ 0 s ]
Total Cells: 9 [ 1 s ]
Total Cells: 4 [ 2 s ]
Total Cells: 7 [ 3 s ]
Total Cells: 6 [ 4 s ]
Total Cells: 5 [ 5 s ]
Total Cells: 4 [ 6 s ]
Total Cells: 2 [ 7 s ]
Total Cells: 0 [ 8 s ]
You can achieve the same result using mutexes by surrounding every increment and decrement of check, t, and living.
Note Using global variables as I have is not good practice, I have done so only to simplify the demonstration of the multithreading, in practice it would be best to wrap them in a namespace, refactor the entire simulation into a class, or something of the like.