Jump to content

katang

Members
  • Content Count

    103
  • Joined

  • Last visited

Everything posted by katang

  1. I have a processor-like construction, and the execution time is simulated in the model using wait(time), i.e. I indend to provide the simulated execution time as argument of sc_start(), to imitate step-wise execution. Can I be sure, that in the model, the simulation will stop 'after' executing the simulated instruction; that is, reaching limiting time will terminate execution at the very end of the delta cycle? The other possibility that timeout is only one of the events, and by chance, it can be NOT the last. BTW: as I understood, a second sc_start() will continue simulation "as it was", i.e. it makes no initialisation, uses no maybe forgotten temporary variables, etc. It is correct? BTW2: How can I find out (at the last instruction) that the simulation finished (no more events left in the engine), and no use to issue another sc_start()?
  2. In my main program, I have declared sc_signal<bool, SC_MANY_WRITERS> main_full("full"); later I attempt to bind it as main_fifo1.fifo_full(main_full); but my compiler keeps saying no match for call to ‘(sc_core::sc_signal<bool, (sc_core::sc_writer_policy)1>) (sc_core::sc_signal<bool, (sc_core::sc_writer_policy)1>&)’ My other module declares sc_signal<bool, SC_MANY_WRITERS> fifo_full; With the other policy, I have no problem with binding. What do I wrong?
  3. I want to share some modules; something similar to when HW threads share the same physical core, but they run different SW threads. My idea is that I need vectors of events and data structures. When using static threads, I cannot change simply and safely the thread, and actually, I need to repeat the code for the threads., Even if I use dynamic threads, and can have parameters, the processes must be distinguished and I need several handles. I would need something as when an item on an event vector sends notification, the shared common code receives the index of the item in the vector. Quite similar as the different instantiations of an object share the code, but not their data. Is there any mechanism for what I want to do?
  4. Concerning the waiting: the next_trigger header tells next_trigger() uses all the syntax of wait(), and behaves as if the actual process of "waiting" occurs after the method exits. The next sentence gives a hint, that it "may gain the effect of a wait" but does tell that ! ONLY if I use it in a state machine!. By using a state variable member in the module class, a method may gain the effect of a wait as illustrated in the following example. example code tells // Wait 1 ns similar to Verilog #1 next_trigger(1,SC_NS); Thanks for the explanation. When one skims the example and attempts to understand the new terms, can easily misinterpret the term. Especially if compared to an already known construction. Sorry. Concerning the timing, could you, please, pinpoint the sentence I took from the book you mentioned. "After initialization, simulation processes are run when events occur to which they are sensitive." In my output, it looks like the main() , without dont_initialize(); is just one of the processes executed at zero time, but not part of the initialization. Correct?
  5. I am not sure, but: with the construction SC_THREAD(Thread_node); // PROBLEMATIC LINE dont_initialize(); you say that "I have a thread, that is not sensitive to any event (==cannot be started later), and should not be started at the beginning. Maybe the kernel is not prepared for such a request. Concerning "to instantiate a arbitrary number of processes": you probably have some upper limit on the number of processes, so you can instantiate that maximum number of modules, and than later you limit the actual (active) modules in the simulation to the random value you generate. I hope this helps.
  6. SC started @ 0 s External host thread initial processing Before Event 1 notified from an external host thread ThreadSafeNotify called @ 0 s After Event 1 notified from an external host thread Event 2 notified from an external host thread ThreadSafeNotify called @ 0 s ThreadSafeUpdate called @ 0 s Got event in triggered @ 0 s Got event after next_trigger(10,SC_NS) @ 0 s Got event in triggered again @ 0 s Initializing main() @ 0 s Wait event in main() @ 15 ns SC returned Maybe this issue deserves a separate thread. The output shows, that the time passes only in thread but not method, or only by wait() but not by next_request()? This explains (for me, at least) why main() does not receive an event. The listing tells that next_trigger() advanced the time, but the next line tells it did not. The wait() does. It seems to me that the engine starts before intializing main(). #include <pthread.h> #include <unistd.h> using namespace sc_core; class ThreadSafeEventIf : public sc_interface { virtual void notify(sc_time delay = SC_ZERO_TIME) = 0; virtual const sc_event &default_event(void) const = 0; protected: virtual void update(void) = 0; }; class ThreadSafeEvent : public sc_prim_channel, public ThreadSafeEventIf { public: ThreadSafeEvent(const char *name = ""): event(name) {} void notify(sc_time delay = SC_ZERO_TIME) { this->delay = delay; std::cout << "ThreadSafeNotify called @ "<<sc_time_stamp()<<std::endl; async_request_update(); } const sc_event &default_event(void) const { return event; } protected: virtual void update(void) { event.notify(delay); std::cout << "ThreadSafeUpdate called @ "<<sc_time_stamp()<<std::endl; } sc_event event; sc_time delay; }; SC_MODULE(Foo) { public: SC_CTOR(Foo) { SC_THREAD(main); sensitive << event; SC_METHOD(eventTriggered); sensitive << event; dont_initialize(); std::cout << "SC started @ "<<sc_time_stamp()<<std::endl; } private: void main() { std::cout << "Initializing main() @ "<<sc_time_stamp()<<std::endl; int i=0; while(i++<3) { wait(15,SC_NS); std::cout << "Wait event in main() @ "<<sc_time_stamp()<<std::endl; wait(); std::cout << "Got event in main() @ "<<sc_time_stamp()<<std::endl; } } void eventTriggered() { std::cout << "Got event in triggered @ "<<sc_time_stamp()<<std::endl; next_trigger(10,SC_NS); std::cout << "Got event after next_trigger(10,SC_NS) @ "<<sc_time_stamp()<<std::endl; next_trigger(); std::cout << "Got event in triggered again @ "<<sc_time_stamp()<<std::endl; } public: ThreadSafeEvent event; }; void *externalHostThread(void *arg) { std::cout << "External host thread initial processing" << std::endl; for(int i=0; i<100; i++){ i += 1;} Foo* foo = (Foo*)(arg); std::cout << "Before Event 1 notified from an external host thread" << std::endl; foo->event.notify(); std::cout << "After Event 1 notified from an external host thread" << std::endl; for(int i=0; i<100; i++){ i += 1;} std::cout << "Event 2 notified from an external host thread" << std::endl; foo->event.notify(); } int sc_main(int argc, char *argv[]) { Foo foo("foo"); pthread_t thread; pthread_create(&thread, NULL, externalHostThread, &foo); sc_start(); std::cout << "SC returned" << std::endl; return 0; }
  7. I wonder what is wrong with using usleep(). If I replace it with a dummy cycle, my output is as shown below Interestingly/importantly: 1/ Initializing main() appears where I expected, and correspondingly the event is received also in main(). However, this seems to be a random event; most of the outputs show that main() is intialized only !after! the events serviced, see the 2nd output. 2/ Event2 is sent and received as expected, but 'main()' persist hiding Maybe async_request_update() was not designed to be used right at the beginning of the simulation and something is not initalized? SC started External host thread initial processing Before Event 1 notified from an external host thread ThreadSafeNotify called Initializing main()After Event 1 notified from an external host thread Event 2 notified from an external host thread ThreadSafeNotify called ThreadSafeUpdate called Got event in triggered Got event after next_trigger(10,SC_NS) Got event in triggered again ThreadSafeUpdate called Got event in triggered Got event after next_trigger(10,SC_NS) Got event in triggered again Got event in main() SC returned SC started External host thread initial processing Before Event 1 notified from an external host thread ThreadSafeNotify called After Event 1 notified from an external host thread Event 2 notified from an external host thread ThreadSafeNotify called ThreadSafeUpdate called Got event in triggered Got event after next_trigger(10,SC_NS) Got event in triggered again Initializing main() SC returned
  8. I am getting confused. My output is SC started External host thread started Before Event 1 notified from an external host thread ThreadSafeNotify called After Event 1 notified from an external host thread ThreadSafeUpdate called Got event in triggered Got event after next_trigger Got event in triggered again Initializing main() SC returned I expected 1/ main() is executed before anything starts 2/ also the "After usleep" and "Event 2" messages appear #include <systemc> #include <pthread.h> #include <unistd.h> using namespace sc_core; class ThreadSafeEventIf : public sc_interface { virtual void notify(sc_time delay = SC_ZERO_TIME) = 0; virtual const sc_event &default_event(void) const = 0; protected: virtual void update(void) = 0; }; class ThreadSafeEvent : public sc_prim_channel, public ThreadSafeEventIf { public: ThreadSafeEvent(const char *name = ""): event(name) {} void notify(sc_time delay = SC_ZERO_TIME) { this->delay = delay; std::cout << "ThreadSafeNotify called\n"; async_request_update(); } const sc_event &default_event(void) const { return event; } protected: virtual void update(void) { event.notify(delay); std::cout << "ThreadSafeUpdate called\n"; } sc_event event; sc_time delay; }; SC_MODULE(Foo) { public: SC_CTOR(Foo) { SC_THREAD(main); sensitive << event; SC_METHOD(eventTriggered); sensitive << event; dont_initialize(); std::cout << "SC started\n"; } private: void main() { std::cout << "Initializing main()" << std::endl; int i=0; while(i++<3) { wait(); std::cout << "Got event in main()" << std::endl; } } void eventTriggered() { std::cout << "Got event in triggered" << std::endl; next_trigger(10,SC_NS); std::cout << "Got event after next_trigger" << std::endl; next_trigger(); std::cout << "Got event in triggered again" << std::endl; } public: ThreadSafeEvent event; }; void *externalHostThread(void *arg) { std::cout << "External host thread started" << std::endl; Foo* foo = (Foo*)(arg); std::cout << "Before Event 1 notified from an external host thread" << std::endl; foo->event.notify(); std::cout << "After Event 1 notified from an external host thread" << std::endl; usleep(10 * 1000 * 1000); // Just for the example std::cout << "After usleep from an external host thread" << std::endl; std::cout << "Event 2 notified from an external host thread" << std::endl; foo->event.notify(); } int sc_main(int argc, char *argv[]) { Foo foo("foo"); pthread_t thread; pthread_create(&thread, NULL, externalHostThread, &foo); sc_start(); std::cout << "SC returned" << std::endl; return 0; }
  9. Sorry, I noticed that I did not insert the new source code So, the output again is SC started SC first event notified ThreadSafeNotify called External host thread started Event 1 notified from an external host thread ThreadSafeNotify called ThreadSafeUpdate called Got event in triggered SC returned I am missing 1/ why the "Event2 notified" line is missing (the thread should terminate only after printing it) As the output is prompt, I guess the thread terminates before reaching printing The update() is called after the second notify(); I expected it is called after the third notify() 2/ I expected a "Got event in main()" message, too #include <systemc> #include <pthread.h> #include <unistd.h> using namespace sc_core; class ThreadSafeEventIf : public sc_interface { virtual void notify(sc_time delay = SC_ZERO_TIME) = 0; virtual const sc_event &default_event(void) const = 0; protected: virtual void update(void) = 0; }; class ThreadSafeEvent : public sc_prim_channel, public ThreadSafeEventIf { public: ThreadSafeEvent(const char *name = ""): event(name) {} void notify(sc_time delay = SC_ZERO_TIME) { this->delay = delay; std::cout << "ThreadSafeNotify called\n"; async_request_update(); } const sc_event &default_event(void) const { return event; } protected: virtual void update(void) { event.notify(delay); std::cout << "ThreadSafeUpdate called\n"; } sc_event event; sc_time delay; }; SC_MODULE(Foo) { public: SC_CTOR(Foo) { SC_THREAD(main); sensitive << event; SC_METHOD(eventTriggered); sensitive << event; dont_initialize(); std::cout << "SC started\n"; std::cout << "SC first event notified\n"; event.notify(); } private: void main() { int i=0; while(i++<3) { wait(); std::cout << "Got event in main()" << std::endl; } } void eventTriggered() { std::cout << "Got event in triggered" << std::endl; } public: ThreadSafeEvent event; }; void *externalHostThread(void *arg) { std::cout << "External host thread started" << std::endl; Foo* foo = (Foo*)(arg); std::cout << "Event 1 notified from an external host thread" << std::endl; foo->event.notify(); usleep(1 * 1000 * 1000); // Just for the example std::cout << "Event 2 notified from an external host thread" << std::endl; foo->event.notify(); } int sc_main(int argc, char *argv[]) { Foo foo("foo"); pthread_t thread; pthread_create(&thread, NULL, externalHostThread, &foo); sc_start(); std::cout << "SC returned" << std::endl; return 0; }
  10. It looks like I could not understand some essential points of async_request_update() In the sample program below (if the usleep in externalHostThread is commented out, the output is) SC first event notified ThreadSafeNotify called External host thread started Event 1 notified from an external host thread ThreadSafeNotify called Event 2 notified from an external host thread ThreadSafeNotify called ThreadSafeUpdate called Got event in triggered SC returned if it is uncommented, the output is SC started SC first event notified ThreadSafeNotify called External host thread started Event 1 notified from an external host thread ThreadSafeNotify called ThreadSafeUpdate called Got event in triggered SC returned 1/ That is, I do receive the event in the SC_METHOD, but not in the SC_THREAD 2./ If the delay (imitating some useful processing) is active, the 2nd event is not sent out, the thread returns early. Whay do I wrong?
  11. I have found a complete code example (the location is shown at the bottom), that operates with wait(time); the method proposed by David Black, too. The source code argumentation seems to be reasonable, and the example works with the vast sleep times. It seems to me that for some reason the waiting does not work: the timing of the event makes the synchronization, rather than the event notification sent after the timing is over. The code below produces the output SC started External host thread started Done 1 Done 2 Done 3 Event 1 notified from an external host thread Event 2 notified from an external host thread Got event SC returned With these timings, the second event is not sent at all, and neither of the wait() operations works. It looks that I missed the point, why. #include <systemc> #include <pthread.h> #include <unistd.h> using namespace sc_core; class ThreadSafeEventIf : public sc_interface { virtual void notify(sc_time delay = SC_ZERO_TIME) = 0; virtual const sc_event &default_event(void) const = 0; protected: virtual void update(void) = 0; }; class ThreadSafeEvent : public sc_prim_channel, public ThreadSafeEventIf { public: ThreadSafeEvent(const char *name = ""): event(name) {} void notify(sc_time delay = SC_ZERO_TIME) { this->delay = delay; async_request_update(); } const sc_event &default_event(void) const { return event; } protected: virtual void update(void) { event.notify(delay); } sc_event event; sc_time delay; }; SC_MODULE(Foo) { public: SC_CTOR(Foo) { SC_THREAD(main); SC_METHOD(eventTriggered); sensitive << event; dont_initialize(); std::cout << "SC started\n"; } private: void main() { usleep(1000); // Just for the example, event is added to pending events during this sleep wait(SC_ZERO_TIME); // Schedule (event is evaluated here) std::cout << "Done 1" << std::endl; usleep(1000); // Just for the example // wait(SC_ZERO_TIME); // Schedule (event is evaluated here) wait(1,SC_MS); std::cout << "Done 2" << std::endl; usleep(1 * 1000 * 1000); // Just for the example, event is added to pending events during this sleep std::cout << "Done 3" << std::endl; usleep(2 * 1000 * 1000); // Just for the example, event is added to pending events during this sleep } void eventTriggered() { std::cout << "Got event" << std::endl; } public: ThreadSafeEvent event; }; void *externalHostThread(void *arg) { std::cout << "External host thread started" << std::endl; Foo* foo = (Foo*)(arg); usleep(1500 * 1000); // Just for the example std::cout << "Event 1 notified from an external host thread" << std::endl; foo->event.notify(); usleep(1 * 1000 * 1000); // Just for the example std::cout << "Event 2 notified from an external host thread" << std::endl; foo->event.notify(); } int sc_main(int argc, char *argv[]) { Foo foo("foo"); pthread_t thread; pthread_create(&thread, NULL, externalHostThread, &foo); sc_start(); std::cout << "SC returned" << std::endl; return 0; } //https://stackoverflow.com/questions/49814756/async-request-update-example-in-systemc
  12. So you say that rather than stalling in SystemC, I need to wait for a SystemC event generated by the GUI? then the SystemC thread can emit a signal, and the two guys can ping-pong with the signals? It sounds good, thank you. That is, as @David Blacksuggested, I shall use the async_request_update() method from the thread, running SystemC? Is some sample around? in the book and the examples I do not find a call like this.
  13. My case is less complex. I am aware of that this process is not that process, and this scheduler is not that scheduler. My intention is exactly just to stall SystemC at some point of execution, and just to read some variables for displaying it in the GUI. I am interested in sc_time only from the aspect to display it in the GUI. I do not want any other communication, than emitting a message that SystemC stalled, then -- after finishing the GUI update -- to resume it. A kind of breakpoint. In the same way as used in a debugger. To resume, I can ask the thread to send a message. I wonder if I can stall SystemC safely, without interfering with anything. Maybe SC_ZERO_TIME solves the problem; however the simulation itself also uses SC_ZERO_TIME in some cases; so they may interfere; I need to check. I do not want to use non-zero time as it falsifies the simulation time, which is also important.
  14. As I mentioned in a previous post, I want to display the state of the simulated object in a GUI thread, while the simulation thread is suspended. Can I do that in an elegant way? I mean, that if I am after receiving my event, the event queue is empty, so the simulation stops immediately. If I suspend it before triggering the event, then the event queue is empty again; so my waiting terminates again. If I trigger the event first, then I stop at a wait(resume-event), the simulation goes to serve the event first, I wanted to stop at; and comes back to my wait(resume-event), and since the event queue is empty, stops again. I guess I need to forcefully prevent taking out the event before the GUI thread returned a resume_event. How can I do that?
  15. I have an educational-purpose GUI that displays the results of the simulation. The simulation is started in the run() method of a Qt5 thread. 1./ At some checkpoints the simulation suspends itself (receives an event, but does not execute it until the GUI sends a resume message), and the GUI can display whatever it wants. I wonder if I need to make any special trick because the GUI and the simulation are in different threads? (As I understood, the engine is just waiting, hopefully nothing happens that would interfere with the threading. I would prefer reading some values directly, just to display them, and avoid sending messages, if not absolutely needed.) 2./ As it is a kind of debugger, it may happen that the user terminates the simulation in a way that the simulation is still waiting for a resume message, but instead a new 'start' message arrives. What is the preferred way of quietly killing the engine? Is it OK, if I terminate and re-start the Qt thread?
  16. I am trying to assemble a package from my app. I builds and executes fine. All other 'make XX' commands work OK, except that when I attempt 'make package', it throws the error message CPackDeb: - Generating dependency list CMake Error at /usr/share/cmake-3.10/Modules/CPackDeb.cmake:709 (message): CPackDeb: dpkg-shlibdeps: 'dpkg-shlibdeps: error: cannot find library libsystemc.so.2.3 needed by I do have libsystemc.so.2.3.3 in my /opt/systemc/lib, and have a libsystemc.so.2.3 to it. The message comes from if(NOT SHLIBDEPS_RESULT EQUAL 0) message (FATAL_ERROR "CPackDeb: dpkg-shlibdeps: '${SHLIBDEPS_ERROR}';\n" Given that during building and running everything works OK (i.e. the library found, I guess that it is in the right place), I have no idea whether it is my dust, or CMake/SystemC? Maybe CPackDeb is looking for it on some other place?
  17. It is defined as #define SCTIME_CLOCKTIME sc_time(100,sc_core::SC_PS)
  18. Sorry. The question was bad. I meant that the self-notification is delayed, so it is not immediate any more. Do I miss something?
  19. I am using a FIFO in my design and in some cases I need to push back the slightly modified content to the FIFO. I understand that sending immediate self-notification should be avoided. To do so, I modified the sample FIFO code as void write(FIFO_t* c) { if (num_elements == max) wait(FIFO_read_event); data[(first + num_elements) % max] = c; ++ num_elements; // wait(SCTIME_CLOCKTIME); // Avoid immediate notification FIFO_write_event.notify(SCTIME_CLOCKTIME); } In the combination shown above, I receive no warning. However, when I define the notification time by the wait() (now commented out) and notify() brackets are empty, I receive the warning Warning: (W536) immediate self-notification ignored as of IEEE 1666-2011: My guess was that the two cases are equivalent. What is the difference? Maybe only the syntax is checked and not the time difference?
  20. You are absolutely right, thank you. From point of view of programming, it is OK. Till now, however, I never thought about ports that one create them with new 🙂
  21. Sorry, I forgot to mention: I have a master port, like this sc_port<scBus_blocking_if> bus_port; If I understand the point correctly, I shall use pointer, that (still within the constructor) I can change from the default null.
  22. I have some modules of the same class, and only part of the instances needs access to a certain bus, the others should not be linked to the bus. Of course I know during the setup phase, which ones should and which ones should not. The ones that should connect, I can connect, it works fine. At the same time, for the others, I would like to tell the ports they should not be connected. Is there some method to do so (i.e. I want to avoid 'complete binding failed', not more) . Or, shall I subclass a new module class for those modules, with the only difference that they have an extra port? Or, shall I give those modules a very low priority (they surely will not use the bus), and connect them formally to the bus? (maybe it causes unneeded wiring) I.e.
  23. First of all, thank you for the quick and effective help. To be frank, I found the conan approach attractive because otherwise it is rather tedious to start up a new project; I guess the same feeling triggered you to assemble and publish the package. My naive idea was that both myself when I assemble a new working environment as well as my users installing the package on their own system, will set up the system using conan (i.e. we do not need to hunt down the individual packages, sometimes finding version compatibility problems), and after that we can rely on the CMake environment as before. That is I do not need conan in the followings, but I need it heavily when I start up. So, the ideal would be not a "CMake only" (where I DO NEED to deal with the packages and their dependencies), and not a "conan only" (where I come out from the normal CMake environment) handling. I would prefer the combined way. Maybe you should have a look at the the package and devote a couple of sentences in the readme file to this aspect. I think that what you call "conan-only" version, meets my needs (except that in the section "Build the project (it will download the needed libraries) and run it:" after cmake .. a make shall also be inserted). I think it is a very useful contribution, especially for the beginners and non-professional developers. I think, however, that every single development must start immediately at the very beginning with testing; so it would be great to complete this contribution with a testing example. I would suggest to make one more update. In the conanfile.txt you say [options] SystemC:stdcxx=14 and in CMakeLists.txt set(CMAKE_CXX_STANDARD 14) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) find_package(SystemC REQUIRED) if(SystemC_FOUND) As the SystemC (AFAIK) defaults standard to '98 and it can be set independently; it may make confusion if you use this makefile with another sources, compiled independently (library version mismatch). In my own sources I use set (CMAKE_CXX_STANDARD ${SystemC_CXX_STANDARD} CACHE STRING "C++ standard to build all targets. Supported values are 98, 11, and 14.") of course after find_package(SystemCLanguage CONFIG REQUIRED) I think this can prevent some potential questions and bugs. (BTW: SystemC or SystemClanguage is the preferred utilization)
  24. Well, up to that point is everything fine. In the next step I attempt to add gtest using line gtest/1.8.1@bincrafters/stable The message is $ make [ 50%] Linking CXX executable bin/TransactionExample /usr/bin/ld: cannot find -lgmock_maind /usr/bin/ld: cannot find -lgmockd /usr/bin/ld: cannot find -lgtestd collect2: error: ld returned 1 exit status CMakeFiles/TransactionExample.dir/build.make:94: recipe for target 'bin/TransactionExample' failed make[2]: *** [bin/TransactionExample] Error 1 CMakeFiles/Makefile2:67: recipe for target 'CMakeFiles/TransactionExample.dir/all' failed make[1]: *** [CMakeFiles/TransactionExample.dir/all] Error 2 Makefile:83: recipe for target 'all' failed make: *** [all] Error 2 well, I understood that gmock is missing, but AFAIN since 1.8.0 it should come with gtest. In addition, the dependencies are about something similar. No difference if I use conan; somehow gtest depencence is missed.
  25. I recently discovered the conan-style install, but I have difficulties with using it. I started with the quickstart example. My conanfile.txt contains [requires] SystemC/2.3.3@minres/stable SystemCVerification/2.0.0a@minres/stable gtest/1.8.1@bincrafters/stable flex/2.6.4@bincrafters/stable qt5/5.13.0@bincrafters/stable and $ conan remote list conan-center: https://conan.bintray.com [Verify SSL: True] minres: https://api.bintray.com/conan/minres/conan-repo [Verify SSL: True] flex: https://github.com/bincrafters/conan-flex [Verify SSL: True] qt5: https://github.com/bincrafters/conan-qt [Verify SSL: True] gtest: https://github.com/bincrafters/conan-gtest [Verify SSL: True] Shall I do anything else? With this, I receive the message $ sudo conan install .. --build=missing Configuration: [settings] arch=x86_64 arch_build=x86_64 build_type=Release compiler=gcc compiler.libcxx=libstdc++ compiler.version=7 os=Linux os_build=Linux [options] [build_requires] [env] WARN: SystemCVerification/2.0.0a@minres/stable requirement SystemC/2.3.2@minres/stable overridden by your conanfile to SystemC/2.3.3@minres/stable flex/2.6.4@bincrafters/stable: Not found in local cache, looking in remotes... flex/2.6.4@bincrafters/stable: Trying with 'conan-center'... flex/2.6.4@bincrafters/stable: Trying with 'minres'... flex/2.6.4@bincrafters/stable: Trying with 'flex'... flex/2.6.4@bincrafters/stable: Trying with 'qt5'... flex/2.6.4@bincrafters/stable: Trying with 'gtest'... ERROR: Unable to find 'flex/2.6.4@bincrafters/stable' in remotes I.e. gtest can be installed with conan, the rest not ; the same happens with the command line $ conan install qt/5.13.0@bincrafters/stable Do I wrong something? BTW: I receive the message WARN: SystemCVerification/2.0.0a@minres/stable requirement SystemC/2.3.2@minres/stable overridden by your conanfile to SystemC/2.3.3@minres/stable Which is true, I really changed in the conanfile.txt to 2.3.3. Maybe SystemCVerification should be updated. Also, I wanted to install TLM. Does it have similar conan recipe and store?
×
×
  • Create New...