SC_FIFO write : First chance exception - c++

Question

I've written a simple program which will send data from a 2D array from one module to another module, however it does not seem to work and I am not sure why. Here is my code:
Server.h
#include <iostream>
#include "stdafx.h"
using namespace std;
SC_MODULE(Server){
sc_in <bool> clock;
sc_fifo_out <sc_uint<20> > writePath;
bool init_flag;
int numRobots;
void Server_Main();
SC_CTOR(Server){
init_flag = 0;
numRobots = 4;
SC_METHOD(Server_Main){ sensitive << clock.pos(); }
}
};
Server.cpp
#include "stdafx.h"
#include "Server.h"
void Server::Server_Main(){
if (init_flag == 0){
int robotPath[4][5] = {
{ 1, 2, 3, 4, 1 },
{ 2, 1, 6, 3, 4 },
{ 3, 2, 9, 5, 1 },
{ 4, 1, 6, 8, 7 }
};
//Write robot path to Sensor
for (int i = 0; i < numRobots; i++){
for (int j = 0; j < 5; j++){
cout << "SERVER MODULE: Write Robot Paths " << i << ": " << robotPath[i][j] << endl;
writePath.write(robotPath[i][j]);
}
}
init_flag = 1;
}
else{ sc_stop(); }
}
Sensor.h
#include <iostream>
#include "stdafx.h"
using namespace std;
SC_MODULE(Sensor){
//sc_in <bool> clock;
sc_fifo_in <sc_uint<20> > readPath;
int robotPath[4][5];
void loadPath();
//void Sensor_Main();
SC_CTOR(Sensor){
//SC_METHOD(Sensor_Main){ sensitive << clock.pos(); }
SC_THREAD(loadPath){}
}
};
Sensor.cpp
#include "stdafx.h"
#include "Sensor.h"
void Sensor::loadPath(){
int i = 0;
int j = 0;
while (1){
robotPath[i][j] = readPath.read();
cout << "SENSOR MODULE: Read Robot " << i << " Path " << j << " : " << robotPath[i][j] << endl;
if (j == 4){
j = 0; //Set index to beginning of array
i++; //Move to next robot
}
else{ j++; } //Continue loading path for current robot
}
}
Main.cpp
#include "stdafx.h"
#include <iostream>
#include "Sensor.h"
#include "Server.h"
using namespace std;
int sc_main(int argc, char* argv[])
{
sc_clock clock("sysclock", 50, SC_MS, .5);
sc_fifo <sc_uint<20> > robotPath;
Sensor sensor_mod("Sensor");
sensor_mod.readPath(robotPath);
Server server_mod("Server");
server_mod.clock(clock);
server_mod.writePath(robotPath);
sc_start();
return 0;
}
Here's what my output looks like:
Here's the error i get from VS2013:
The program seems to throw an exception when it tries to write robotPath[3][1] to the fifo but im not sure why. I specified my fifo size to be 20 so that it can store 20 values at once but I dont send more than 20 values and this exception is happening when i try to write the 17th value so maybe im misunderstanding the use of sc_fifo_out. It might be some obvious mistake im overlooking but im kind of burnt out at this point and cannot figure out what it is im messing up.

Answer 1

Are you trying to model a Hardware design using SystemC or trying to use SystemC for software modelling?
It seems you have mixed up the contexts.
Here are a list of pointers you need to consider:
In Server module Server_Main() should be registered as a SC_THREAD:
SC_THREAD(Server_Main);
sensitive << clk.pos();
Since you are using sc_fifo's write method which internally calls wait(), in SystemC it is illegal to use wait in a SC_METHOD.
Modify the Server.cpp as mentioned below:
void Server::Server_Main() {
int robotPath[4][5] = {{ 1, 2, 3, 4, 1 },
{ 2, 1, 6, 3, 4 },
{ 3, 2, 9, 5, 1 },
{ 4, 1, 6, 8, 7 }};
//Write robot path to Sensor
for (int i = 0; i < numRobots; i++){
for (int j = 0; j < 5; j++){
cout << "SERVER MODULE: Write Robot Paths " << i << ": " << robotPath[i][j] << endl;
writePath.write(robotPath[i][j]);
wait(); //< Notice this wait statement.
}
}
}
Add a wait() statement in the while loop of the Sensor.cpp.
Also sc_fifo< sc_uint<20> > is not instantiating a sc_fifo with depth 20 as you might think.
It is actually instantiating a sc_fifo with sc_uint<20> as the datatype which is used for modelling a 20-bit unsigned integer, and the default depth of fifo as 16 as per the SystemC specs.
You can instantiate a sc_fifo<> with depth 20 as mentioned below:
sc_fifo<sc_uint<20> > robotPath("robotPath", 20);
Note: You don't need to do this since the above change from SC_METHOD to SC_THREAD and also updating the Server_Main will invalidate this behavior.