SC_FIFO запись: Исключение первого шанса

Я написал простую программу, которая будет отправлять данные из 2D-массива из одного модуля в другой, однако она не работает, и я не знаю, почему. Вот мой код:

Сервер.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(); }
    }
};

Сервер.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(); }
}

Сенсор.ч

#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){}
    }
};

Датчик.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;
}

Вот как выглядит мой вывод:

введите здесь описание изображения

Вот ошибка, которую я получаю от VS2013: введите здесь описание изображения

Программа, кажется, выдает исключение, когда пытается записать robotPath[3][1] в fifo, но я не уверен, почему. Я указал размер моего FIFO равным 20, чтобы он мог хранить 20 значений одновременно, но я не отправляю более 20 значений, и это исключение происходит, когда я пытаюсь записать 17-е значение, поэтому, возможно, я неправильно понимаю использование sc_fifo_out. Это может быть какая-то очевидная ошибка, которую я упускаю из виду, но я немного сгорел в этот момент и не могу понять, что я испортил.


c++ visual-studio-2013 fifo systemc
person Javia1492    schedule 21.03.2017    source источник

Ответы (1)


arrow_upward
1
arrow_downward

Вы пытаетесь смоделировать аппаратное обеспечение с помощью SystemC или пытаетесь использовать SystemC для моделирования программного обеспечения?
Похоже, вы перепутали контексты.

Вот список указателей, которые вам необходимо учитывать:

  • В модуле Сервер Server_Main() должен быть зарегистрирован как SC_THREAD:

    SC_THREAD(Server_Main);
sensitive << clk.pos();

    Поскольку вы используете метод записи sc_fifo, который внутренне вызывает wait(), в SystemC использование ожидания в SC_METHOD является незаконным.

  • Измените Server.cpp, как указано ниже:

    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.
    }
  }
}

  • Добавьте оператор wait() в цикл while файла Sensor.cpp.

  • Кроме того, sc_fifo‹ sc_uint‹20> > не создает экземпляр sc_fifo с глубиной 20, как вы могли бы подумать.
    На самом деле он создает экземпляр sc_fifo с sc_uint‹20> в качестве типа данных, который используется для моделирования 20-битного целого числа без знака, и глубины fifo по умолчанию равной 16 в соответствии со спецификациями SystemC.

    Вы можете создать экземпляр sc_fifo‹> с глубиной 20, как указано ниже:

    sc_fifo<sc_uint<20> > robotPath("robotPath", 20);

    Примечание. Вам не нужно этого делать, так как указанное выше изменение с SC_METHOD на SC_THREAD, а также обновление Server_Main сделают это поведение недействительным.

person AmeyaVS    schedule 23.03.2017
comment
Когда вы говорите, что преобразование из SC_METHOD в SC_THREAD сделает поведение недействительным, что вы имеете в виду? Если у меня есть запись одного потока и чтение другого потока, но только для чтения после того, как я записал 20 образцов в fifo, разве мне не нужно такое поведение? - person Javia1492; 09.04.2017
comment
@Javia1492 Если вам нужно такое поведение, когда fifo записывается с 20 выборками, а затем запускает выполнение Sensor::loadPath() [поток], вам придется изучить статическую и динамическую чувствительность спецификаций SystemC. - person AmeyaVS; 10.04.2017