I am new to Specman, and try to use Temporal expression for event which have to trigger every 16 cycle of specific clock.
Can I do the following
event f_clk is 6*clk?
If not , how can I do it?
a * 16 will lead to having clk_16 emitted every cycle, starting from the 16th cycle. to avoid this behavior, you can write this:
event clk_16 is {[16] * not #clk_16} #clk;
Related
According to ABAP Documentation, the command WAIT UP TO x SECONDS needs an operand of type i. However, I'd like to WAIT UP TO x Milliseconds or something similar. Neither official documentation nor several other forum posts have been helpful thus far.
Is there any way to specify a wait for a fraction of a second?
You can simply pass a decimal value like:
WAIT UP TO '0.5' SECONDS
or something like:
WAIT UP TO '0.01' SECONDS
See also How to make an abap program pause.
If you want to avoid implicit commit with WAIT UP TO, create a simple RFC function:
FUNCTION ZSLEEP .
*"--------------------------------------------------------------------
*"*"Lokale Schnittstelle:
*" IMPORTING
*" VALUE(DURATION) TYPE SDURATION_SECONDS
*"--------------------------------------------------------------------
* To wait 50 milliseconds write this:
* DATA duration TYPE sduration_seconds VALUE '0.050'.
* CALL FUNCTION 'ZSLEEP' DESTINATION 'NONE' KEEPING LOGICAL UNIT OF WORK EXPORTING duration = duration.
WAIT UP TO duration SECONDS.
ENDFUNCTION.
I've just solved it like this:
DATA: timestart TYPE timestampl,
timeend TYPE timestampl,
millisecs TYPE timestampl,
imilli TYPE i VALUE 200.
GET TIME STAMP FIELD timestart.
millisecs = imilli / 1000.
timestart = timestart + millisecs.
DO.
GET TIME STAMP FIELD timeend.
IF timestart < timeend.
EXIT.
ENDIF.
ENDDO.
WRITE timeend.
If I now rewrite this as a function taking an integer as an import parameter (in place of imilli) I'll - to my knowledge - have exactly what I wanted.
I'll leave this up for a little before tagging it as the correct answer in the hopes that someone may have a better / more elegant solution.
Without asking about the requirement, 2 ways to do this are
GET RUN TIME
where SET RUN TIME CLOCK RESOLUTION can be important.
or
GET TIME STAMP using a target field TIMESTAMPL
Do not use WAIT UP TO for fine time frames due to the Workprocess switching.
Wait also carries other side effects not immediately obvious.
I am trying to simulate a customer by using agents. In the statechart I built, I would like to apply to each individual agent the waiting time spent in the system by defining different variables:
WatingTimeStart, WaitingTimeEnd and WaitingTime
In order to assign the waiting time to each agent I am using the following command in the transition prior to the state I would like to apply the condition:
this.WaitingTimeStart=time();
In the next State I am then using the following:
this.WaitingTimeEnd=time();
this.WaitingTime=this.WaitingTimeEnd-this.WaitingTimeStart;
Followed by the next transition with the condition (TolerarableWaitingTime is a pre-defined Variable)
this.WaitingTime>TolerarableWaitingTime;
My Problem is the transition does not accept the condition and is not processing the agents to the next state.
I probably make a mistake in:
assinging the variable WaitingTime to each agent
applying the condition correcly
Thanks a lot for any thoughts.
Bastian
It was difficult to understand your question, but here it goes: first, you don't need to use "this", you can just do in the transition previous to the state in question:
WaitingTimeStart=time();
also by convention your variables should start with a low case letter, so it should be waitingTimeStart.
But you don't really even need that code and you are overcomplicating yourself... if you want to apply a waiting time (or a delay) you don't need a conditional transition, you can just use a timeout transition instead, where the timeout time is equal to TolerarableWaitingTime
I have something like that:
scoreHolder.addSoftConstraintMatch(kcontext, (System.currentTimeMillis()-$time.getTime()));
I want to use the current time at the beginning of firing the rule only, and not to be updated during running the rule. just to catch the current time at the first moment the rule is fired and does not change till the end of solving.
I'm using optaplanner 6.1.
thanks in advance.
That would break OptaPlanner, as the Score of the same Solution would change over time (which also implies that comparing 2 different Solutions can not be done fairly - so if a new working score is compared to the best score (which was calculated x seconds ago) it breaks).
Instead, before the solver starts, set the current time millis in a singleton:
myParametrization.setStartingMillis(System.currentMillis());
... = solver.solve(...);
and add that as a problem fact and use it in the score rules (see examination example's InstitutionParameterization).
I want to run the series of codes continuously at a regular time interval and stop when a given condition is met
You need a combination of looping or repetition, along with a timestamp check.
There are several options available in VB.Net:
Use a Do Until or Do While loop with a delay
Example:
Do Until Now > [time]
[code]
System.Threading.Thread.Sleep([delay in milliseconds])
Loop
Advantage: Reliable and simple.
Disadvantage: Ties up your processing, unless use some kind of multithreading, like a BackgroundWorker.
Use a Timer
Example:
Inside the Timer.Tick Event:
If Now < [time]
[code]
Else
Timer.Enabled = False
End If
Advantage: Simple and does not tie up your main thread.
Disadvantage: Sometimes can skip ticks.
I have recorded real-time stock quotes in an SQL database with fields Id, Last, and TimeStamp. Last being the current stock price (as a double), and TimeStamp is the DateTime when the price change was recorded.
I would like to replay this stream in the same way it came in, meaning if a price change was originally 12 seconds apart then the price change event firing (or something similar) should be 12 seconds apart.
In C# I might create a collection, sort it by the DateTime then fire an event using the difference in time to know when to fire off the next price change. I realize F# has a whole lot of cool new stuff relating to events, but I don't know how I would even begin this in F#. Any thoughts/code snippets/helpful links on how I might proceed with this?
I think you'll love the F# solution :-).
To keep the example simple, I'm storing the price and timestamps in a list containing tuples (the first element is the delay from the last update an the second element is the price). It shouldn't be too difficult to turn your input data into this format. For example:
let prices = [ (0, 10.0); (1000, 10.5); (500, 9.5); (2500, 8.5) ]
Now we can create a new event that will be used to replay the process. After creating it, we immediatelly attach some handler that will print the price updates:
let evt = new Event<float>()
evt.Publish.Add(printfn "Price updated: %f")
The last step is to implement the replay - this can be done using asynchronous workflow that loops over the values, asynchronously waits for the specified time and then triggers the event:
async { for delay, price in prices do
do! Async.Sleep(delay)
evt.Trigger(price) }
|> Async.StartImmediate
I'm starting the workflow using StartImmediate which means that it will run on the current thread (the waiting is asynchronous, so it doesn't block the thread). Keeping everything single-threaded makes it a bit simpler (e.g. you can safely access GUI controls).
EDIT To wrap the functionality in some component that could be used from other parts of the application, you could define a type like this:
type ReplyDataStream(prices) =
let evt = new Event<float>()
member x.Reply() =
// Start the asynchronous workflow here
member x.PriceChanged =
evt.Publish
The users can then create an instance of the type, attach their event handlers using stream.PriceChanged.Add(...) and then start the replaying the recorded changes using Reply()