What Is a Vega Machine?

The risk elements of options are usually represented by Greek letters, including: delta value, gamma value, theta value, vega value, rho value, charm value, etc.

vega value

Vega value is the sensitivity of an option to fluctuations in the underlying asset price volatility. It reflects that when the volatility changes by one unit (usually measured by 1%), the option

Correct

If some

Vega value function introduction

vgsystem is a property function that is used to set actions and notifications that control errors, frame updates, multiprocessing settings, and how to properly exit the application. Replaces all properties set by default by Lynx or by using the vgprop function. Use the vgGetprop function to query the settings; use the vgGetSys function to get the vgSystem function.

vega program application

Error handling

Turn the floating-point error indicator on or off by turning the system property VGSYS_FPERROR on or off. The default is VG_OFF. If set to VG_ON, in addition to replacing the system and trying to restore the program, vega also encloses its own floating point number. When VGSYS_FPERROR is on, set the notification layer to VG_INFO or the console with a floating point error as described above. In addition to optimizing the operation of the program, the user needs to minimize the number of floating-point numbers. The user can set the error message indicated on the console. After that, set the attribute VGSYS_NOTIFY to one of the following layers, and list them in order of decreasing importance:

VG_FATAL may cause an exit;

VG_WARN-may fail or not fail;

VG_NOTICE-there may be errors or structural problems;

VG_INFO-print error information for users;

VG_DEBUG-used for program debugging.

As long as the severity of the error message is more severe than the current layer, the message to be published is written to the standard output device; otherwise, the published message is invalid. The source of the error message may be the vega system or the user's application. For example, the setup code for receiving all messages is

vgSystem * sys;

sys = vgGetSys ();

vgProp (sys, VGSYS_NOTIFY, VG_DEBUG);

Message inserted into debug layer in user code using the following format

YgNotify (VG_DEBUG, VG_APP ,,);

YgNotify (VG_DEBUG, VG_APP, "this is an example debug notice at line% ld." ._ LINE_);

Frame management

The default value of the VGSYS_FRAMERATE parameter is 300, which represents the number of unit frames that are updated and displayed every second.

The setting of VGSYS_PHASE specifies the synchronization method used by the vgsyncFrame function and the drawing thread (if it is a separate thread). One of the attributes in the following parameter values can be given.

VGSYS_FREERUN-the default state. Allows the application to execute at any speed; the defined frame rate is not valid.

VGSYS_LIMIT-same as VGSYS_FREERUN, but lower than the defined frame rate.

Vega's executor (or vega process) is a single-window process that has multiple threads at the connections before and after it. Threads are a basic unit of the operating system that allocates processor time. In order to get an optimal execution on a given machine, the user must configure vega in a system running in multiple threads.

The three main vega threads are request (app), selection, and drawing, each of which can be executed as a separate thread, or executed in any combination of two threads, or executed in three threads, and the user can also choose for the cross process A separate thread, one for database loading and another for light spot calculations. When the memory paging geometry uses large area database management (LADBM), or the user's own memory paging geometry requires a database load thread.

When selecting a multi-threaded mode, use the vgProp function to set VGSYS_MPMODE to one of the following 5 types:

VGSYS_MPDEFAULT-Lets the tether determine the best structure for the CPU on the target machine.

VGSYS_MP0 Set a default LL thread for request, selection and drawing.

VGSYS_MP1-set two threads, request and select in one thread, and draw in another thread.

VGSYS_MP3-Set up three threads * for request, selection and drawing respectively.

The user can control the thread processor (CPU) running on the system, set the drawing thread and priority in the window properties, and set the selection thread, light point thread, and priority in the channel properties. Appropriate CPU number to set, app CPU. If the number of CPUs is 0, the number of CPUs on the system is -1. The default value of -1 indicates that no dedicated CPU is allocated. At this time, the operating system will determine the time for each thread to run using CN. If the specified number of CPUs does not exist on a machine dedicated to running vega applications, a warning is placed on the machine and the thread is really specified as -1.

The user can also control the priority of thread timing. The priority of each thread is determined by the following criteria:

Vega priority classes handled by Vega;

The vega priority layer of the thread in the vega priority class processed by vega;

The priority class and priority layer are combined into a basic priority form of a thread;

The range of priority parameter values processed by vega is 31-39. The larger the parameter value is, the smaller the priority is. It is best to use 32.

Table 3.1 describes the meaning of the vega priority parameter values.

The VGSYS_VEGAPRI attribute of vgsystem is used to select the vega process priority class. Note that this priority is only available under vegaNT and does not exist in vega on SGI.

The vega thread priority layer has a range of 31-39. When 32 is used, the priority is the highest.

Note: In order to solve the problem of compatibility between platforms, the numerical values used to specify the priority class of vega and the priority of the thread layer are different from the actual numerical values of those items used by Windows, vegaNT will put Table 3.1 And the values in Table 3.2 are converted to values suitable for WiIndows.

The VGSYS_APPPRI attribute of the vgSystem function is used to select the priority layer of the Vega thread for the requesting thread;

The VGSYS_ISECTPROC component of the vgSystem function is used to select an asynchronous cross thread. When another CPU is active, F is used when processing human traffic: Use the vGSYS_ISECTCPU attribute to the CPU of the remote cross thread and its The running priority is set. The thread is defined with the VGSYS_ISECTPRI attribute.

The VGSYS_DBPROC attribute of the vgsystem function is used to select an asynchronous database thread, which is used when the memory is decibels in the geometry during runtime (transparent processing by the vega LADBM model). The VGSYS_DBPRI attribute is used to set the CPU running the database thread and the priority of the process running on it. The database is defined using the VGSYS_DBCPU attribute.

The VGSYS_LPOINTPROC attribute of the vgSysdem function is used to select a synchronized light spot thread that runs in comparison with the drawing thread and direction and calculates visibility for the light spot.

System callback

There are 7 types of callbacks below. These callbacks are registered by the system using the vgAddFunc public program function call.

VGSYS_PRESYNC Only called before pfSync;

vGSYS_POSTSYNC-called after pfSync and after synchronizing with the IO device;

vGSYS_PRECONFIG-called only before system configuration;

VGSYSPOSTCONPIG Called after configuring the system:

VGSYS_PREFRAME-only called before pfFrame;

VGSYS_POSTFRAME called after PfFrame;

VGSYS_EXIT-called from the vgExit function after the user exits the called function.

Exit system

The user's application should not call Exit. To properly exit the application in sequence, the vgExit function can be called, and an integer is sent to the vgExit function. If the user's application exits the system with an incorrect result, the code will be made negative.

If you exit a task with a result of the user code, you need to use the vgUserExit function to install the user's exit function after calling the vgIniSys function. -Once the installation is complete, the user's exit function will be called with the vgExit program. If you do not want your function to terminate your program, your exit function should return -1. Be particularly careful when using the vgExit function. The vgExit function is not called internally by the user's registered callback function to avoid an infinite loop. The user model can also install the VGSYS_EXIT callback function, so they will be notified when the vgExit function is called using the test.

Using the vgExitKey function will cause the system to record a key. When the input is opened, selecting this tin will cause the program to exit. The plating is given by its ASCII code. If this plating is not specified, the vgGetExitKey function will return the previously defined exit key ASCII code, or -1 if it is currently undefined. When any program opens a window to confirm that the defined chain has been pressed, the vgExitt function is called. The window where the mouse cursor is is the current window. As long as an input is made on the current window, the window will recognize whether the key is pressed.

time

The vgGettime function returns the time to call the vgInitSys function in seconds. The return value is a double-precision floating-point number with the highest accuracy supported by the system. The vgGetRunTime function returns the time it takes to draw the first frame in seconds: the vgGetFrameTime function returns the drawing from the beginning. The time between calling the vgFrame function after the first frame arrives; the vgGetDeltaFrameTime function returns the time between the start point of the current frame and the start point of the previous frame.

double vgGetTime (void);

double vgGetRunTime (void);

double vgGetFrameTime (void);

double vgGetDeltaFrameTime (void);

Usability

Vega also provides 4 additional functions to add to the content related to vega product modules (ie special effects, LADBM).

int vgAddModAvail (char * name);

int vgPindModAvail (char * name);

char * vgGeModAvail (int idx);

int v8GetNumModAvail (void);

The vgAddModAvail function is called by the initial function of a product module, which adds the module name to the list of available modules. This does not open or provide any relevant named product modules, but simply places the product module names in a list that can be queried from the kernel. As a special case. When a product module is initialized, after determining that the license agreement is valid for its operation, the cell adds the name of the product module to the list.

If a specific product module is used by the user, the function vgFindModAvail can be called at any time after using the function vgConfigSys to query the availability of the module. You need to provide the module name to this function, it returns an indexed list of query product names, or -1 if the product module is not available. The vgGetModAvail function returns the name of a product module through the index number in the list, and the starting value of the index number is ().

The vgGetNumModAvail function returns the number of product modules in the list.

Event management

The information contained in this section is helpful for the development of vega product modules. A product module is a library that provides new features for vega. The following introduces the basic concepts of managing events in vega. This is not expected to make a product module a function of a real application.

The modeling behavior provided by vega is through self-managed event notifications and self-managed event activities. The self-managing nature of these events allows vega product modules to communicate with each other. The vega Class Recorder (vega Class Recorder c_vegaVCR) is also an optional Vega product module, so when an event (event activity) needs to occur, use this device to notify those same modules that the module event has occurred:

#include

void vgRegisterInstance (vgCommon * handle, void * name);

unsigned vgAddEventFunc (vgCalback * eventHandler, size_t event DataSize);

void vgEvent () ccurred (vgCommon * handle, unsigned eventId, void * edata):

The vgRegisterInstance () function is used to record vega or product module class events using any module that requires such notification. The parameters are as follows;

handle-a pointer to the registered event handle.

name-vega class name or product module event using the handle being registered.

The following code shows how a special effects module should use a special VCR event to record all its events.

unsigned num = vgGetNumFx ();

for (i = 0; i <num; i)

vgAddEventFunc ((vgFx *) vgGeoFX (i), vcrName);

The vgAddEventFunc () function allows the product module to use the module address provided by the vega event function for recording. The event function is called when vega processes and rebuilds a special event. The vgAddEventFunc () function returns a product module and uses the vega event identifier eventId that introduced the event. Its parameters are:

EventHandler-A pointer to the address of the event manager that manages this particular event. The device controls how to reconstruct the details of the event.

EventDataSize-the size of the data associated with the event in bytes.

vegaVCR is an example of using a product module of the agency. When in PLAyBACK mode, the VCR encounters an event identifier (eventId) packet, which contains an event identifier that is not within the valid range of a pre-specified vegaVCR event The VCR will call the registered event function module, which is equivalent to the event identifier eventId of the product module information package, and is used to notify the product module that an event needs to occur. The following code shows an example of how an application registers an event manager to determine the crossing mask for crossing a node using methods that control intersection, selection, and drawing.

unsigned afterburnerEventId = vgAddEventFunc (setAfterBurners, sizeof (float));

The vgEventOccurred function is used to notify that a Vega event has occurred. Vega can notify any module that needs this kind of discipline. Its parameters are:

Handle-A pointer to the event handle of the event just obtained.

EventId-The only parameter value describing the event (this value is returned from the vvgAddEventFunc function).

Edata-a pointer to a data structure that contains everything necessary to process and reconstruct the event

Piece of data.

The following code illustrates how a special effects module notifies

time.

void vgFxSetTime (vgFx * fx, int which, doubte val)

{

struct_eventdata

{

double val;

int which;

} eventdata;

switch ((vgFxTimeProp) which)

{

case VGFX_STARTTIME;

if (val = VGFX_NOW)

{

st = vgGetTime () eventdata.val = val;

}

else {st = val;

eventdata.val = val-vgGetTime ();

break;

...

vgEventOccurred (fx, setTimeEventId, & eventdata);

}