Menu
My personal decoder for playing non-web-supported videos
Please, choose a video file to upload and convert to a web based format:
Loading!


Alumni Association of CSE, GUB is to provide an incentive for members to direct highly qualified and motivated potential candidates to the CSE department; to aid the Department in its future development both in an advisory and financial capacity; to sponsor social and professional activities of the Alumni Association and also to involve in various activities to serve the society along with the current students of the Department.
The Alumni Association of CSE, GUB shall promote the interests, welfare and educational aims of GUB and its alumni, establish and maintain a mutually beneficial relationship between CSE Department and its alumni, and encourage lifelong engagement of CSE, GUB alumni with their fellow alumni and the University community.
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Vero odio fugiat voluptatem dolor, provident officiis, id iusto! Obcaecati incidunt, qui nihil beatae magnam et repudiandae ipsa exercitationem, in, quo totam.


Leigh Griffiths makes Celtic goalscoring return as he nets reserve double
The Hoops star is back among the goals ahead of a huge month for his club.
by Mark McDougall, https://www.dailyrecord.co.uk/authors/mark-mcdougall/Celtic striker Leigh Griffiths was back among the goals as he grabbed a double for the club's reserve team.
The Hoops youngsters took on Stenhousemuir in a friendly at Lennoxtown with Griffiths handed a striking role.
He hasn't played for Celtic's first team since a 12 minute cameo against Hearts in August.
But he made an instant impact for the second string by scoring after 11 minutes. The 29-year-old was picked out by David McKay and he slipped the ball into the back of the net.
Griffiths added a second three minutes later and this time it was former Rangers youngster Liam Burt who provided the assist.
Burt moved across the divide in the summer and he played a stunning through ball to Griffiths who smashed it past the keeper.
Burt then grabbed a double of his own as Celtic cruised into a dominant lead before half time and he got his hat-trick 10 minutes into the second half. Cameron Harper added a sixth.
Also involved for the Hoops was Ireland U21 striker Jonathan Afolabi, who will be hoping to make his first team debut this season.
A return to form for Griffiths would be good news for Neil Lennon as he heads into some tough fixtures.
With 10 games over December before the winter break, the Hoops had looked likely to be relying on Odsonne Edouard.


resource odbc_tableprivileges ( resource $connection_id , string $qualifier , string $owner , string $name )
Lists tables in the requested range and the privileges associated with each table.
An ODBC result identifier or FALSE on failure. The result set has the following columns: TABLE_QUALIFIER TABLE_OWNER TABLE_NAME GRANTOR GRANTEE PRIVILEGE IS_GRANTABLE The result set is ordered by TABLE_QUALIFIER, TABLE_OWNER and TABLE_NAME.


Implementation Type Constructor Parameters¶
Normally we do not need to specify constructor parameters when specifying type bindings, since the constuctor parameters will be injected. However, in some cases we want to explicitly specify constructor parameter values in bound type.
Here are some of the cases when explicitly specifying constructor parameters might be useful:
The bound type has multiple constructors, and we want to explicitly specify which constructor should be used.
The bound type constructor has some parameters, which cannot be injected since no bindings are provided for the types of these parameters.
We want to explicitly specify the constructor parameter values (say for primitive types, such as System.Int32, System.Double, etc), instead of relying on IoC container to inject these constructor parameter values.
Note
Normally, if there are multiple constructors, the IoC container will pick the constructor with largest number of parameters. This pattern is true for Autofac and Ninject, however might be different for other implementations.
Element parameters¶
Use parameters in element implementation or selfBoundService to provide constructor parameter values.
If parameters is used without any values (see Example 1 below), than the default constructor will be used to construct an instance of bound type, even if there are other constructors. In this case an exception will be thrown if the bound type does not have a default constructor. To let the IoC pick the constructor, do not use any parameters element in implementation and selfBoundService elements.
IoC.Configuration will use parameter serializers specified in element iocConfiguration/parameterSerializers to de-serialize the values of parameters specified in child elements of element parameters (see Parameter Serializers).
When the IoC.Configuration uses reflection to find the constructor using parameter types specified under parameters element. If no constructor is found, and exception will be thrown.
Example 1¶
In the example below, type DynamicallyLoadedAssembly1.Implementations.SelfBoundService1 is bound to itself.
When injecting an instance of DynamicallyLoadedAssembly1.Implementations.SelfBoundService1, the object will be constructed using the constructor with three parameters of types System.Int32, System.Double, and DynamicallyLoadedAssembly1.Interfaces.IInterface1.
The first and second parameter values will be de-serialized from textual values 14 and 15.3.
The third parameter value will be injected by IoC.Configuration, since injectedObject is used for this parameter. A binding for DynamicallyLoadedAssembly1.Interfaces.IInterface1 should be specified in XML configuration file or in modules being loaded.
Note
IoC.Configuration will automatically register a self bound service for a type specified in element injectedObject, if the type is not an abstract type or an interface, and if it is not already registered in configuration file. Therefore, if in example below we replace DynamicallyLoadedAssembly1.Interfaces.IInterface1 with DynamicallyLoadedAssembly1.Interfaces.IInterface1_Implementation (i.e., non-abstract implementation of DynamicallyLoadedAssembly1.Interfaces.IInterface1), there will be no need to provide a binding for DynamicallyLoadedAssembly1.Interfaces.IInterface1_Implementation.
Note
Using injectedObject, we can specify a type other than a type registered for interface DynamicallyLoadedAssembly1.Interfaces.IInterface1 (i.e., the type of parameter param3). In other words, no matter what bindings are specified for interface DynamicallyLoadedAssembly1.Interfaces.IInterface1, the object injected for parameter param3 will be of type specified in injectedObject element.
<selfBoundService type="DynamicallyLoadedAssembly1.Implementations.SelfBoundService1"
assembly="dynamic1"
scope="singleton">
<parameters>
<int32 name="param1" value="14" />
<double name="param2" value="15.3" />
<injectedObject name="param3"
type="DynamicallyLoadedAssembly1.Interfaces.IInterface1"
assembly="dynamic1" />
</parameters>
</selfBoundService>
Example 2¶
In the example below, interface SharedServices.Interfaces.IRoom is bound to class SharedServices.Implementations.Room.
When injecting an instance of SharedServices.Interfaces.IRoom, an object of type SharedServices.Implementations.Room will be constructed using a constructor with two parameter, both of type SharedServices.Interfaces.IDoor.
The first parameter value will be de-seriazed from string “5,185.1” provided in attribute value in element object. A parameter serializer for type SharedServices.Interfaces.IDoor should be specified in element iocConfiguration/parameterSerializers/serializers (see Parameter Serializers for more details).
The second parameter value will be injected by IoC.Configuration, since injectedObject is used for parameter value.
Note
IoC.Configuration will automatically register a self bound service for a type specified in element injectedObject, if the type is not an abstract type or an interface, and if it is not already registered in configuration file. Therefore, no need to register a binding for type SharedServices.Interfaces.OakDoor used in injectedObject for parameter door2, since this type is non-abstract and non-interface.
Note
Using injectedObject, we can specify a type other than a type registered for interface SharedServices.Interfaces.IDoor (i.e., the type of parameter door2). In other words, no matter what bindings are specified for interface SharedServices.Interfaces.IDoor, the object injected for parameter door2 will be of type specified in injectedObject element.
<service type="SharedServices.Interfaces.IRoom" assembly="shared_services">
<implementation type="SharedServices.Implementations.Room"
assembly="shared_services"
scope="transient">
<parameters>
<object name="door1" type="SharedServices.Interfaces.IDoor"
assembly="shared_services"
value="5,185.1" />
<injectedObject name="door2" type="SharedServices.Interfaces.OakDoor"
assembly="shared_services" />
</parameters>
</implementation>
</service>
Example 3¶
In the example below, a default constructor will be used to construct an instance of SharedServices.Implementations.Interface8_Impl1, even though type SharedServices.Implementations.Interface8_Impl1 has also a non default constructor. The reason the default constructor is picked is that empty parameters element is used under element implementation.
<service type="SharedServices.Interfaces.IInterface8"
assembly="shared_services">
<implementation type="SharedServices.Implementations.Interface8_Impl1"
assembly="shared_services"
scope="singleton">
<parameters>
</parameters>
</implementation>
</service>
In the example below, non-default constructor will be used to construct an instance of SharedServices.Implementations.Interface8_Impl1, since no parameters element is used, and the type SharedServices.Implementations.Interface8_Impl1 has both parameter-less constructor as well as constructor with parameters.
<service type="SharedServices.Interfaces.IInterface8"
assembly="shared_services">
<implementation type="SharedServices.Implementations.Interface8_Impl1"
assembly="shared_services"
scope="singleton">
</implementation>
</service>


Index
secondary: intensive: parpharat
derivatives: -pharvī phárvara RV. phā́riva RV. parpharī́ka RV.
All the derivatives of doubtful meaning and connection.


Amber Gill has no interest in a man and says Ovie Soko is 'like a brother' to her
Love Island winner Amber has been linked with her former co-star lately but says there's no time for anyone except herself as she continues to rake in the cash
by Sam Elliott, Ed Gleave, https://www.mirror.co.uk/authors/sam-elliott/Bad news, boys - Amber Gill just hasn't got any interest in having another man in her life.
The Love Island winner says she is just too busy to give serious consideration to a new relationship.
The beauty, 22, has spoken to the Daily Star on Sunday about the next chapter in her life months after leaving the hit show.
But the story won't have a new boyfriend written into it if he comments are anything to go by.
She said: “I haven’t got time for it. And I don’t want to take the shine off what I’m doing because it really is an amazing opportunity.”
There have been rumours of a secret romance with co-star Ovie Soko, but Amber insists he’s more like her “brother” than a love interest.
Amber’s feisty attitude won over the public on Love Island.
Viewers saw her standing up for herself when she was treated badly and it made her the heroine of the last series.
Months later, she is still getting messages from women who say they have been inspired by her.
Amber said: “They’re like, ‘You’ve taught me I can stand up for myself. I don’t have to go back to this person who’s treating me badly’.
“I had no idea I was doing anything special – moving on from people who treat you badly is just standard for me.
“But so many girls put up with it, which is crazy. What are they doing? I’m glad I showed other people they could do the same as me.”
During her time on Love Island, Amber had a turbulent relationship with hunk Michael Griffiths.
In scenes that stunned viewers, he ditched her for another girl.
Looking back at the drama, Amber remains unimpressed by the way he behaved.
She said: “What Michael did was just so nasty, but that’s the way some people are.
“It all worked out in my favour, so I can’t be too mad about it.”
Amber went on to find happiness with Greg O’Shea and they won the show as a couple.
Within weeks of leaving the TV villa their relationship was over.
She was living it up in London while he stayed in Ireland. In a chat with Weekend mag, Amber said: “It was really hard. We tried, but we were both just so busy doing really interesting things we didn’t get an opportunity to build anything properly.
“I was hoping the relationship would go somewhere.
“I think it was just about us being in different countries. If it had all happened in private, it wouldn’t have been so upsetting. But if he wanted to end things, I’m glad he did it sooner rather than later.”


Martin has added a customer Successfully
Jennifer purchased Light Dashboard 2.0.
Robin marked a ticket as unsolved.
David purchased Light Dashboard 1.0.
James. has added acustomer Successfully
Active
Hey! there I'm available
Images
This theme is awesome!
Nice to meet you
Next meeting tomorrow 10.00AM
Admin-A.zip
typing
Yeah everything is fine
Good morning
Hi, How are you?
I've finished it! See you so
Wow that's great
Name
Email
Time
Location
10:00
Good morning, How are you? What about our next meeting?
10:02
10:05
& Next meeting tomorrow 10.00AM
10:06
10:09
12.5 MB
10:16
Start Audio Call
Start Video Call


The {@link oaj.http.remote.Remote @Remote} annotation is used on your interface class
to identify it as a REST proxy interface.
- {@link oaj.http.remote.Remote}
- {@link oaj.http.remote.Remote#path path}
- {@link oaj.http.remote.Remote#headers headers}
- {@link oaj.http.remote.Remote#version version}
- {@link oaj.http.remote.Remote#versionHeader versionHeader}
The @Remote annotation is optional but often included for code readability.
@Remote(path)
The {@link oaj.http.remote.Remote#path @Remote(path)} annotation is used to define the
HTTP path of the REST service.
The path can be an absolute path to your REST service.
| @Remote(path="http://localhost:10000/petstore")
| public interface PetStore {...}
| PetStore store = client.getRemote(PetStore.class);
VarResolver.DEFAULT can also be used in the path.
| // URL is specified via a system property.
| @Remote(path="$S{PetStoreUrl}")
| public interface PetStore {...}
When a relative path is specified, it's relative to the root-url defined on the RestClient used to instantiate the interface.
| @Remote(path="/petstore")
| public interface PetStore {...}
| RestClient client = RestClient
| .create()
| .json()
| .rootUrl("http://localhost:10000")
| .build();
|
| PetStore store = client.getRemote(PetStore.class);
When no path is specified, the root-url defined on the RestClient is used.
| @Remote
| public interface PetStore {...}
| RestClient client = RestClient
| .create()
| .json()
| .rootUrl("http://localhost:10000/petstore")
| .build();
|
| PetStore store = client.getRemote(PetStore.class);
@Remote(headers/headerList)
The {@link oaj.http.remote.Remote#headers @Remote(headers)} and {@link oaj.http.remote.Remote#headerList @Remote(headerList)}
annotations are used to add headers on all requests.
| @Remote(
| path="/petstore",
| headers={
| "Foo: bar",
| "Baz: $S{bazProperty}"
| },
| headerList=MyHeaderList.class
| )
| public interface PetStore {...}
| // Our dynamic supplier.
| public class MyHeaderList extends HeaderList {
| ...
| }
@Remote(version/versionHeader)
The {@link oaj.http.remote.Remote#version @Remote(version)} and {@link oaj.http.remote.Remote#versionHeader @Remote(versionHeader)}
annotations are used to specify the client-side version of this interface that can be used on the server side
to perform version-specific handling.
| @Remote(
| path="/petstore",
| version="1.2.3" // Adds "Client-Version: 1.2.3" header to all requests.
| )
| public interface PetStore {...}
This can be used in conjunction with the server-side client-versioning support.
| // Call this method if Client-Version is at least 2.0.
| // Note that this also matches 2.0.1.
| @RestGet(clientVersion="2.0")
| public Object foo() {...}
|
| // Call this method if Client-Version is at least 1.1 but less than 2.0.
| @RestGet(clientVersion="[1.1,2.0)")
| public Object foo() {...}
|
| // Call this method if Client-Version is less than 1.1.
| @RestGet(clientVersion="[0,1.1)")
| public Object foo() {...}


Hi there and welcome to my website. My name is John Sengson and I am a student at EDA.
This is my first ever website and I am creating this as part of my curriculum.
I have blogs about my time studying, share some of my values, and hopefully later on videos and photos of my time in EDA.
I hope you enjoy your visit and take your time reading my blogs. Not the best but a good read nonetheless.


LIVE FM Radio (Bangladesh Only)
Paused...
Your browser does not support HTML5 Audio! 😢
←
→
Made with ♥ by
Rakibul Yeasin


On Saturday around 6:15 p.m., a group of people threw eggs at a synagogue in Borough Park, according to police.
No person was hit in the incident, but the group, who threw the eggs from the street, managed to hit a wall inside the synagogue, authorities said.
Just a day later on Sunday, around 4:15 p.m., police said a group of at least three people ran up and threw eggs at a 50-year-old woman's back as she walked in Borough Park, just a few blocks from Saturday's synagogue egging.
The group didn't say anything to the woman and no injuries were reported, officials said.
The NYPD is investigating both incidents, as well as a third unconfirmed incident which Boro Park Shomrim tweeted surveillance video from.
The alleged attacks come a mid a rise in anti-Semitic crimes across New York City. More than half the hate crimes reported in the city so far this year are anti-Semitic, NYPD officials said in September.
While most of the incidents reported are acts of vandalism, as a whole, anti-Semitic hate crimes in New York City are up 63% this year as compared with last year, officials have said.


VampirTrace 5.4.12 User Manual
TU Dresden
Center for Information Services and
High Performance Computing (ZIH)
01062 Dresden
Germany
http://www.tu-dresden.de/zih/
http://www.tu-dresden.de/zih/vampirtrace/
E-Mail<EMAIL_ADDRESS>This documentation describes how to prepare application programs in order to have traces generated, when executed. This step is called instrumentation. Furthermore, it explains how to control the run-time measurement system during execution (tracing). This also includes hardware performance counter sampling, as well as selective filtering and grouping of functions.
VampirTrace consists of a tool-set and a run-time library for instrumentation and tracing of software applications. It is particularly tailored towards parallel and distributed High Performance Computing (HPC) applications.
The instrumentation part modifies a given application in order to inject additional measurement calls during run-time. The tracing part provides the current measurement functionality used by the instrumentation calls. By this means, a variety of detailed performance properties can be collected and recorded during run-time. This includes
After a successful trace run, VampirTrace writes all collected data to a trace in the Open Trace Format (OTF), see http://www.tu-dresden.de/zih/otf.
As a result the information is available for post-mortem analysis and visualization by various tools. Most notably, VampirTrace provides the input data for the Vampir analysis and visualization tool, see http://www.vampir.eu.
VampirTrace is included in OpenMPI 1.3 and later. If not disabled explicitly, VampirTrace is built automatically when installing OpenMPI. Refer to http://www.open-mpi.org/faq/?category=vampirtrace for more information.
Trace files can quickly become very large. With automatic instrumentation, even tracing applications that run only for a few seconds can result in trace files of several hundred megabytes. To protect users from creating trace files of several gigabytes, the default behavior of VampirTrace limits the internal buffer to 32 MB. This produces trace files that are not larger than 32 MB per process, typically a lot smaller. Please read Section [*] on how to remove or change the limit.
VampirTrace supports various Unix and Linux platforms common in HPC nowadays. It comes as open source software under a BSD License.
To make measurements with VampirTrace, the user's application program needs to be instrumented, i.e., at specific important points (called ``events'') VampirTrace measurement calls have to be activated. As an example, common events are entering and leaving of function calls, as well as sending and receiving of MPI messages.
By default, VampirTrace handles this automatically. In order to enable instrumentation of function calls, the user only needs to replace the compiler and linker commands with VampirTrace's wrappers, see Section [*] below. VampirTrace supports different ways of instrumentation as described in Section [*].
All the necessary instrumentation of user functions as well as MPI and OpenMP events is handled by VampirTrace's compiler wrappers (vtcc, vtcxx, vtf77, and vtf90). In the script used to build the application (e.g. a makefile), all compile and link commands should be replaced by the VampirTrace compiler wrapper. The wrappers perform the necessary instrumentation of the program and link the suitable VampirTrace library. Note that the VampirTrace version included in OpenMPI 1.3 has additional wrappers (mpicc-vt, mpicxx-vt, mpif77-vt, and mpif90-vt) which are like the ordinary MPI compiler wrappers (mpicc and friends) with the extension of automatic instrumentation.
The following list shows some examples depending on the parallelization type of the program:
| original: | gfortran a.f90 b.f90 -o myprog |
| with instrumentation: | vtf90 a.f90 b.f90 -o myprog |
This will instrument user functions (if supported by compiler) and link the VampirTrace library.
| original: | mpicc hello.c -o hello |
| with instrumentation: | vtcc -vt:cc mpicc hello.c -o hello |
MPI implementations without own compilers require the user to link the MPI library manually. In this case, you simply replace the compiler by VampirTrace's compiler wrapper:
| original: | icc hello.c -o hello -lmpi |
| with instrumentation: | vtcc hello.c -o hello -lmpi |
If you want to instrument MPI events only (creates smaller trace files and less overhead) use the option -vt:inst manual to disable automatic instrumentation of user functions (see also Section [*]).
| original: | ifort -openmp pi.f -o pi |
| with instrumentation: | vtf77 -openmp pi.f -o pi |
For more information about OPARI refer to share/vampirtrace/doc/opari/Readme.html in VampirTrace's installation directory.
| original: | mpif90 -openmp hybrid.F90 -o hybrid |
| with instrumentation: | vtf90 -vt:f90 mpif90 -openmp |
| hybrid.F90 -o hybrid |
The VampirTrace compiler wrappers try to detect automatically which parallelization method is used by means of the compiler flags (e.g. -openmp or -lmpi) and the compiler command (e.g. mpif90). If the compiler wrapper failed to detect this correctly, the instrumentation could be incomplete and an unsuitable VampirTrace library would be linked to the binary. In this case, you should tell the compiler wrapper which parallelization method your program uses by the switches -vt:mpi, -vt:omp, and -vt:hyb for MPI, OpenMP, and hybrid programs, respectively. Note that these switches do not change the underlying compiler or compiler flags. Use the option -vt:verbose to see the command line the compiler wrapper executes. Refer to Appendix [*] for a list of all compiler wrapper options.
The default settings of the compiler wrappers can be modified in the files share/vampirtrace/vtcc-wrapper-data.txt (and similar for the other languages) in the installation directory of VampirTrace. The settings include compilers, compiler flags, libraries, and instrumentation types. For example, you could modify the default C compiler from gcc to mpicc by changing the line compiler=gcc to compiler=mpicc. This may be convenient if you instrument MPI parallel programs only.
The wrapper's option -vt:inst <insttype> specifies the instrumentation type to use. Following values for <insttype> are possible:
| insttype | Compilers |
|---|---|
| gnu | GNU (e.g., gcc, g++, gfortran, g95) |
| intel | Intel version ≥10.0 (e.g., icc, icpc, ifort) |
| pgi | Portland Group (PGI) (e.g., pgcc, pgCC, pgf90, pgf77) |
| phat | SUN Fortran 90 (e.g., cc, CC, f90) |
| xl | IBM (e.g., xlcc, xlCC, xlf90) |
| ftrace | NEC SX (e.g., sxcc, sxc++, sxf90) |
| insttype | |
|---|---|
| manual | VampirTrace's API (see Section [*]) |
| pomp | POMP INST directives (see Section [*]) |
| insttype | |
|---|---|
| dyninst | binary-instrumentation with Dyninst (Section [*]) |
To determine which instrumentation type will be used by default and which other are available on your system take look at the entry inst_avail in the wrapper's configuration file (e.g. share/vampirtrace/vtcc-wrapper-data.txt in the installation directory of VampirTrace for the C compiler wrapper).
See Appendix [*] or type vtcc -vt:help for other options that can be passed through VampirTrace's compiler wrapper.
Automatic Instrumentation is the most convenient way to instrument your program. Simply use the compiler wrappers without any parameters, e.g.:
% vtf90 myprog1.f90 myprog2.f90 -o myprog
To get the application executable for nm during runtime, VampirTrace uses the /proc file system. As /proc is not present on all operating systems, automatic symbol information might not be available. In this case, it is necessary to set the environment variable VT_APPPATH to the pathname of the application executable to get symbols resolved via nm.
Should any problems emerge to get symbol information automatically, then the environment variable VT_NMFILE can be set to a symbol list file, which is created with the command nm, like:
% nm hello > hello.nm
To get the source code line for the application functions use nm -l on Linux systems.
VampirTrace will include this information into the trace.
Note that the output format of nm must be written in BSD-style. See the manual page
of nm to obtain help for dealing with the output format setting.
__attribute__ ((__no_instrument_function__))
The PGI and IBM compilers prefer inlining over instrumentation when compiling with inlining enabled. Thus, one needs to disable inlining to enable instrumentation of inline functions and vice versa.
The bottom line is that you cannot inline and instrument a function at the same time. For more information on how to inline functions read your compiler's manual.
The VT_USER_START, VT_USER_END instrumentation calls can be used to mark any user-defined sequence of statements.
Fortran: #include "vt_user.inc" VT_USER_START('name') ... VT_USER_END('name')
C: #include "vt_user.h" VT_USER_START("name"); ... VT_USER_END("name");If a block has several exit points (as it is often the case for functions), all exit points have to be instrumented by VT_USER_END, too.
For C++ it is simpler, as shown in the following example. Only entry points into a scope need to be marked. Exit points are detected automatically, when C++ deletes scope-local variables.
C++: #include "vt_user.h" { VT_TRACER("name"); ... }
For all three languages, the instrumented sources have to be compiled with -DVTRACE otherwise the VT_* calls are ignored. Note that Fortran source files instrumented this way have to be preprocessed, too.
In addition, you can combine this instrumentation type with all other ones. For example, all user functions can be instrumented by a compiler while special source code regions (e.g. loops) can be instrumented by VT's API.
Use VT's compiler wrapper (described above) for compiling and linking the instrumented source code, like:
% vtcc -vt:inst manual myprog1.c -DVTRACE -o myprog
% vtcc -vt:inst gnu myprog1.c -DVTRACE -o myprog
Note that you can also use the option -vt:inst manual with non-instrumented sources. Binaries created this way only contain MPI and OpenMP instrumentation, which might be desirable in some cases.
POMP (OpenMP Profiling Tool) instrumentation directives are supported for Fortran and C/C++. The main advantage is that by using directives, the instrumentation is ignored during normal compilation.
The INST BEGIN and INST END directives can be used to mark any user-defined sequence of statements. If this block has several exit points, all but the last exit point have to be instrumented by INST ALTEND.
Fortran: !POMP$ INST BEGIN(name) ... [ !POMP$ INST ALTEND(name) ] ... !POMP$ INST END(name)
C/C++: #pragma pomp inst begin(name) ... [ #pragma pomp inst altend(name) ] ... #pragma pomp inst end(name)At least the main program function has to be instrumented in this way, and additionally, the following must be inserted as the first executable statement of the main program:
Fortran: !POMP$ INST INIT
C/C++: #pragma pomp inst init
The option -vt:inst dyninst selects the compiler wrapper to instrument the application during run-time (binary instrumentation) by using Dyninst (http://www.dyninst.org). Recompiling is not necessary for this way of instrumenting, but relinking, as shown:
% vtf90 -vt:inst dyninst myprog1.o myprog2.o -o myprog
The compiler wrapper dynamically links the library libvt.dynatt.so
to the application. This library attaches the Mutator-program
vtdyn during run-time which invokes the instrumenting by using
the Dyninst-API.
Note that the application should have been compiled with the -g
switch in order to have symbol names visible.
After a trace-run by using this way of instrumenting, the vtunify
utility needs to be invoked manually (see Sections [*] and [*]).
To prevent certain functions from being instrumented you can set the environment variable VT_DYN_BLACKLIST to a file containing a newline-separated list of function names. All additional overhead due to instrumentation of these functions will be removed.
VampirTrace also allows binary instrumentation of functions located in shared libraries. Ensure that the shared libraries have been compiled with -g and assign a colon-separated list of their names to the environment variable VT_DYN_SHLIBS, e.g.:
VT_DYN_SHLIBS=libsupport.so:libmath.so
By default, running a VampirTrace instrumented application should result in an OTF trace file in the current working directory where the application was executed. Use the environment variables VT_FILE_PREFIX and VT_PFORM_GDIR described below to change the name of the trace file and its final location. In case a problem occurs, set the environment variable VT_VERBOSE to yes before executing the instrumented application in order to see control messages of the VampirTrace run-time system which might help tracking down the problem.
The internal buffer of VampirTrace is limited to 32 MB. Use the environment variable VT_BUFFER_SIZE and VT_MAX_FLUSHES to increase this limit. Section [*] contains further information on influencing trace file size.
The following environment variables can be used to control the measurement of a VampirTrace instrumented executable:
| Variable | Purpose | Default |
|---|---|---|
| VT_PFORM_GDIR | Name of global directory to store final trace file in | ./ |
| VT_PFORM_LDIR | Name of node-local directory that can be used to store temporary trace files | /tmp/ |
| VT_FILE_PREFIX | Prefix used for trace filenames | a |
| VT_APPPATH | Path to the application executable (see Section [*]) | - |
| VT_BUFFER_SIZE | Size of internal event trace buffer. This is the place where event records are stored, before being written to a file. | 32M |
| VT_MAX_FLUSHES | Maximum number of buffer flushes | 1 |
| VT_VERBOSE | Print VampirTrace related control information during measurement? | no |
| VT_METRICS | Specify counter metrics to be recorded with trace events as a colon-separated list of names. (for details see Appendix [*]) | - |
| VT_MEMTRACE | Enable memory allocation counters? (see Sec. [*]) | no |
| VT_IOTRACE | Enable tracing of application I/O calls? (see Sec. [*]) | no |
| VT_MPITRACE | Enable tracing of MPI events? | yes |
| VT_DYN_BLACKLIST | Name of blacklist file for Dyninst instrumentation (see Section [*]) | - |
| VT_DYN_SHLIBS | Colon-separated list of shared libraries for Dyninst instrumentation (see Section [*]) | - |
| VT_FILTER_SPEC | Name of function/region filter file (see Section [*]) | - |
| VT_GROUPS_SPEC | Name of function grouping file (See Section [*]) | - |
| VT_UNIFY | Unify local trace files afterwards? | yes |
| VT_COMPRESSION | Write compressed trace files? | yes |
| VT_NM | Command to list symbols from object files. (see Section [*]) | nm |
| VT_NMFILE | Name of file with symbol list information. (see Section [*]) | - |
The value for the first three variables can contain (sub)strings of the form $XYZ or ${XYZ} where XYZ is the name of another environment variable. Evaluation of the environment variable is done at measurement run-time.
When you use these environment variables, make sure that they have the same value for all processes of your application on all nodes of your cluster. Some cluster environments do not automatically transfer your environment when executing parts of your job on remote nodes of the cluster, and you may need to explicitly set and export them in batch job submission scripts.
The default values of the environment variables VT_BUFFER_SIZE and
VT_MAX_FLUSHES limit the internal buffer of VampirTrace to
32 MB and the number of times that the buffer is flushed to 1. Events that
should be recorded after the limit has been reached are no longer written into
the trace file. The environment variables apply to every process of a
parallel application, meaning that applications with n processes
will typically create trace files n times the size of a serial
application.
To remove the limit and get a complete trace of an application, set
VT_MAX_FLUSHES to 0. This causes VampirTrace to always
write the buffer to disk when the buffer is full. To change the size of the
buffer, use the variable VT_BUFFER_SIZE. The optimal value for
this variable depends on the application that should be traced. Setting a
small value will increase the memory that is available to the application but
will trigger frequent buffer flushes by VampirTrace. These buffer flushes can
significantly change the behavior of the application. On the other hand,
setting a large value, like 2G, will minimize buffer flushes by
VampirTrace, but decrease the memory available to the application. If not
enough memory is available to hold the VampirTrace buffer and the application
data this may cause parts of the application to be swapped to disk leading
also to a significant change in the behavior of the application.
After a run of an instrumented application the traces of the single processes need to be unified in terms of timestamps and event IDs. In most cases, this happens automatically. But under certain circumstances it is necessary to perform unification of local traces manually. To do this, use the command:
% vtunify <no-of-traces> <prefix>
For example, this is required on the BlueGene/L platform or when using Dyninst
instrumentation.
If VampirTrace has been built with hardware-counter support enabled (see Section [*]), VampirTrace is capable of recording hardware counter information as part of the event records. To request the measurement of certain counters, the user must set the environment variable VT_METRICS. The variable should contain a colon-separated list of counter names, or a predefined platform-specific group. Metric names can be any PAPI preset names or PAPI native counter names. For example, set
VT_METRICS=PAPI_FP_OPS:PAPI_L2_TCM
to record the number of floating point instructions and level 2 cache misses.
See Appendix [*] for a full list of PAPI preset counters.
The user can leave the environment variable unset to indicate that no counters are requested. If any of the requested counters are not recognized or the full list of counters cannot be recorded due to hardware-resource limits, program execution will be aborted with an error message.
The GNU glibc implementation provides a special hook mechanism that allows intercepting all calls to allocation and free functions (e.g. malloc, realloc, free). This is independent from compilation or source code access, but relies on the underlying system library.
If VampirTrace has been built with memory-tracing support enabled (see Section [*]), VampirTrace is capable of recording memory allocation information as part of the event records. To request the measurement of the application's allocated memory, the user must set the environment variable VT_MEMTRACE to yes.
Calls to functions which reside in external libraries can be intercepted by implementing identical functions and linking them before the external library. Such ``wrapper functions'' can record the parameters and return values of the library functions.
If VampirTrace has been built with I/O tracing support, it uses this technique for recording calls to I/O functions of the standard C library which are executed by the application. Following functions are intercepted by VampirTrace:
| open | read | fdopen | fread |
| open64 | write | fopen | fwrite |
| creat | readv | fopen64 | fgetc |
| creat64 | writev | fclose | getc |
| close | pread | fseek | fputc |
| dup | pwrite | fseeko | putc |
| dup2 | pread64 | fseeko64 | fgets |
| lseek | pwrite64 | rewind | fputs |
| lseek64 | fsetpos | fscanf | |
| fsetpos64 | fprintf |
The gathered information will be saved as I/O event records in the trace file. This feature has to be activated for each tracing run by setting the environment variable VT_IOTRACE to yes.
In addition to the manual instrumentation (see Section [*]) the VampirTrace API provides instrumentation calls which allow recording of program variable values (e.g. iteration counts, calculation results, ...) or any other numerical quantity. A user defined counter is identified by its name, the counter group it belongs to, the type of its value (integer or floating-point), and the unit that the value is quoted (e.g. ``GFlop/sec'').
The VT_COUNT_GROUP_DEF and VT_COUNT_DEF instrumentation calls can be used to define counter groups and counters:
Fortran: #include "vt_user.inc" integer :: id, gid VT_COUNT_GROUP_DEF('name', gid) VT_COUNT_DEF('name', 'unit', type, gid, id)
C/C++: #include "vt_user.h" unsigned int id, gid; gid = VT_COUNT_GROUP_DEF('name'); id = VT_COUNT_DEF("name", "unit", type, gid);
The definition of a counter group is optionally. If no special counter group is desired the default group ``User'' can be used. In this case, set the parameter gid of VT_COUNT_DEF to VT_COUNT_DEFGROUP.
The third parameter type of VT_COUNT_DEF specifies the data type of the counter value. To record a value for any of the defined counters the corresponding instrumentation call VT_COUNT_*_VAL must be invoked.
| Fortran: | ||
|---|---|---|
| Type | Count call | Data type |
| VT_COUNT_TYPE_INTEGER | VT_COUNT_INTEGER_VAL | integer (4 byte) |
| VT_COUNT_TYPE_INTEGER8 | VT_COUNT_INTEGER8_VAL | integer (8 byte) |
| VT_COUNT_TYPE_REAL | VT_COUNT_REAL_VAL | real |
| VT_COUNT_TYPE_DOUBLE | VT_COUNT_DOUBLE_VAL | double precision |
| C/C++: | ||
|---|---|---|
| Type | Count call | Data type |
| VT_COUNT_TYPE_SIGNED | VT_COUNT_SIGNED_VAL | signed int (max. 64-bit) |
| VT_COUNT_TYPE_UNSIGNED | VT_COUNT_UNSIGNED_VAL | unsigned int (max. 64-bit) |
| VT_COUNT_TYPE_FLOAT | VT_COUNT_FLOAT_VAL | float |
| VT_COUNT_TYPE_DOUBLE | VT_COUNT_DOUBLE_VAL | double |
The following example records the loop index i:
Fortran: #include "vt_user.inc" program main integer :: i, cid, cgid VT_COUNT_GROUP_DEF('loopindex', cgid) VT_COUNT_DEF('i', '#', VT_COUNT_TYPE_INTEGER, cgid, cid) do i=1,100 VT_COUNT_INTEGER_VAL(cid, i) end do end program main
C/C++: #include "vt_user.h" int main() { unsigned int i, cid, cgid; cgid = VT_COUNT_GROUP_DEF('loopindex'); cid = VT_COUNT_DEF("i", "#", VT_COUNT_TYPE_UNSIGNED, cgid); for( i = 1; i <= 100; i++ ) { VT_COUNT_UNSIGNED_VAL(cid, i); } return 0; }
For all three languages the instrumented sources have to be compiled with -DVTRACE. Otherwise the VT_* calls are ignored. If additionally any functions or regions are manually instrumented by VT's API (see Section [*]) and only the instrumentation calls for user defined counter should be disabled, then the sources have to be compiled with -DVTRACE_NO_COUNT, too.
By default, all calls of instrumented functions will be traced, so that the resulting trace files can easily become very large. In order to decrease the size of a trace, VampirTrace allows the specification of filter directives before running an instrumented application. The user can decide on how often an instrumented function/region is to be recorded to a trace file. To use a filter, the environment variable VT_FILTER_SPEC needs to be defined. It should contain the path and name of a file with filter directives.
Below, there is an example of a file containing filter directives:
# VampirTrace region filter specification # # call limit definitions and region assignments # # syntax: <regions> -- <limit> # # regions semicolon-separated list of regions # (can be wildcards) # limit assigned call limit # 0 = region(s) denied # -1 = unlimited # add;sub;mul;div -- 1000 * -- 3000000
These region filter directives cause that the functions add, sub, mul and div to be recorded at most 1000 times. The remaining functions * will be recorded at most 3000000 times.
Besides creating filter files by hand, you can also use the vtfilter tool to generate them automatically. This tool reads the provided trace and decides whether a function should be filtered or not, based on the evaluation of certain parameters. For more information see Section [*].
VampirTrace allows assigning functions/regions to a group. Groups can, for instance, be highlighted by different colors in Vampir displays. The following standard groups are created by VampirTrace:
| Group name | Contained functions/regions |
|---|---|
| MPI | MPI functions |
| OMP | OpenMP constructs and functions |
| MEM | Memory allocation functions (see [*]) |
| I/O | I/O functions (see [*]) |
| Application | remaining instrumented functions and source code regions |
Additionally, you can create your own groups, e.g. to better distinguish different phases of an application. To use function/region grouping set the environment variable VT_GROUPS_SPEC to the path of a file which contains the group assignments. Below, there is an example of how to use group assignments:
# VampirTrace region groups specification # # group definitions and region assignments # # syntax: <group>=<regions> # # group group name # regions semicolon-separated list of regions # (can be wildcards) # CALC=add;sub;mul;div USER=app_*
These group assignments make the functions add, sub, mul and div associated with group ``CALC'' and all functions with the prefix app_ are associated with group ``USER''.
vtcc,vtcxx,vtf77,vtf90 - compiler wrappers for C, C++, Fortran 77, Fortran 90 Syntax: vt<cc|cxx|f77|f90> [-vt:<cc|cxx|f77|f90> <cmd>] [-vt:inst <insttype>] [-vt:<seq|mpi|omp|hyb>] [-vt:opari <args>] [-vt:verbose] [-vt:version] [-vt:showme] [-vt:showme_compile] [-vt:showme_link] ... options: -vt:help Show this help message. -vt:<cc|cxx|f77|f90> <cmd> Set the underlying compiler command. -vt:inst <insttype> Set the instrumentation type. possible values: gnu fully-automatic by GNU compiler intel ... Intel (version >= 10.x) ... pgi ... Portland Group (PGI) ... phat ... SUN Fortran 90 ... xl ... IBM ... ftrace ... NEC SX ... manual manual by using VampirTrace's API pomp manual by using using POMP INST directives dyninst binary by using Dyninst (www.dyninst.org) -vt:opari <args> Set options for OPARI command. (see share/vampirtrace/doc/opari/Readme.html) -vt:<seq|mpi|omp|hyb> Force application's parallelization type. Necessary, if this cannot be determined by underlying compiler and flags. seq = sequential mpi = parallel (uses MPI) omp = parallel (uses OpenMP) hyb = hybrid parallel (MPI + OpenMP) (default: automatically determining by underlying compiler and flags) -vt:verbose Enable verbose mode. -vt:showme Do not invoke the underlying compiler. Instead, show the command line that would be executed. -vt:showme_compile Do not invoke the underlying compiler. Instead, show the compiler flags that would be supplied to the compiler. -vt:showme_link Do not invoke the underlying compiler. Instead, show the linker flags that would be supplied to the compiler. See the man page for your underlying compiler for other options that can be passed through 'vt<cc|cxx|f77|f90>'. Environment variables: VT_CC Equivalent to '-vt:cc' VT_CXX Equivalent to '-vt:cxx' VT_F77 Equivalent to '-vt:f77' VT_F90 Equivalent to '-vt:f90' VT_INST Equivalent to '-vt:inst' The corresponding command line options overwrite the environment variable settings. Examples: automatically instrumentation by using GNU compiler: vtcc -vt:cc gcc -vt:inst gnu -c foo.c -o foo.o vtcc -vt:cc gcc -vt:inst gnu -c bar.c -o bar.o vtcc -vt:cc gcc -vt:inst gnu foo.o bar.o -o foo manually instrumentation by using VT's API: vtf90 -vt:inst manual foobar.F90 -o foobar -DVTRACE IMPORTANT: Fortran source files instrumented by VT's API or POMP directives have to be preprocessed by CPP.
vtunify - local trace unifier for VampirTrace. Syntax: vtunify <#files> <iprefix> [-o <oprefix>] [-c|--compress <on|off>] [-k|--keeplocal] [-v|--verbose] Options: -h, --help Show this help message. #files number of local trace files (equal to # of '*.uctl' files) iprefix prefix of input trace filename. -o <oprefix> prefix of output trace filename. -s <statsofile> statistics output filename default=<oprefix>.stats -q, --noshowstats Don't show statistics on stdout. -c, --nocompress Don't compress output trace files. -k, --keeplocal Don't remove input trace files. -v, --verbose Enable verbose mode.
vtdyn - Dyninst Mutator for VampirTrace. Syntax: vtdyn [-v|--verbose] [-s|--shlib <shlib>[,...]] [-b|--blacklist <bfile> [-p|--pid <pid>] <app> [appargs ...] Options: -h, --help Show this help message. -v, --verbose Enable verbose mode. -s, --shlib Comma-separated list of shared libraries <shlib>[,...] which should also be instrumented. -b, --blacklist Set path of blacklist file containing <bfile> a newline-separated list of functions which should not be instrumented. -p, --pid <pid> application's process id (attaches the mutator to a running process) app path of application executable appargs application's arguments
vtfilter - filter generator for VampirTrace Syntax: Filter a trace file using an already existing filter file: vtfilter -filt [filt-options] <input trace file> Generate a filter: vtfilter -gen [gen-options] <input trace file> general options: -h, --help show this help message -p show progress filt-options: -to <file> output trace file name -fi <file> input filter file name -z <zlevel> Set the compression level. Level reaches from 0 to 9 where 0 is no compression and 9 is the highest level. Standard is 4. -f <n> Set max number of file handles available. Standard is 256. gen-options: -fo <file> output filter file name -r <n> Reduce the trace size to <n> percent of the original size. The program relies on the fact that the major part of the trace are function calls. The approximation of size will get worse with a rising percentage of communication and other non function calling or performance counter records. -l <n> Limit the number of accepted function calls for filtered functions to <n>. Standard is 0. -ex <f>,<f>,... Exclude certain symbols from filtering. A symbol may contain wildcards. -in <f>,<f>,... Force to include certain symbols into the filter. A symbol may contain wildcards. -inc Automatically include children of included functions as well into the filter. -stats Prints out the desired and the expected percentage of file size. environment variables: TRACEFILTER_EXCLUDEFILE Specifies a file containing a list of symbols not to be filtered. The list of members can be seperated by space, comma, tab, newline and may contain wildcards. TRACEFILTER_INCLUDEFILE Specifies a file containing a list of symbols to be filtered.
Available counter names can be queried with the PAPI commands
papi_avail and papi_native_avail.
There are limitations to the combinations of counters. To check
whether your choice works properly, use the command
papi_event_chooser.
PAPI_L[1|2|3]_[D|I|T]C[M|H|A|R|W] Level 1/2/3 data/instruction/total cache misses/hits/accesses/reads/writes PAPI_L[1|2|3]_[LD|ST]M Level 1/2/3 load/store misses PAPI_CA_SNP Requests for a snoop PAPI_CA_SHR Requests for exclusive access to shared cache line PAPI_CA_CLN Requests for exclusive access to clean cache line PAPI_CA_INV Requests for cache line invalidation PAPI_CA_ITV Requests for cache line intervention PAPI_BRU_IDL Cycles branch units are idle PAPI_FXU_IDL Cycles integer units are idle PAPI_FPU_IDL Cycles floating point units are idle PAPI_LSU_IDL Cycles load/store units are idle PAPI_TLB_DM Data translation lookaside buffer misses PAPI_TLB_IM Instruction translation lookaside buffer misses PAPI_TLB_TL Total translation lookaside buffer misses PAPI_BTAC_M Branch target address cache misses PAPI_PRF_DM Data prefetch cache misses PAPI_TLB_SD Translation lookaside buffer shootdowns PAPI_CSR_FAL Failed store conditional instructions PAPI_CSR_SUC Successful store conditional instructions PAPI_CSR_TOT Total store conditional instructions PAPI_MEM_SCY Cycles Stalled Waiting for memory accesses PAPI_MEM_RCY Cycles Stalled Waiting for memory Reads PAPI_MEM_WCY Cycles Stalled Waiting for memory writes PAPI_STL_ICY Cycles with no instruction issue PAPI_FUL_ICY Cycles with maximum instruction issue PAPI_STL_CCY Cycles with no instructions completed PAPI_FUL_CCY Cycles with maximum instructions completed PAPI_BR_UCN Unconditional branch instructions PAPI_BR_CN Conditional branch instructions PAPI_BR_TKN Conditional branch instructions taken PAPI_BR_NTK Conditional branch instructions not taken PAPI_BR_MSP Conditional branch instructions mispredicted PAPI_BR_PRC Conditional branch instructions correctly predicted PAPI_FMA_INS FMA instructions completed PAPI_TOT_IIS Instructions issued PAPI_TOT_INS Instructions completed PAPI_INT_INS Integer instructions PAPI_FP_INS Floating point instructions PAPI_LD_INS Load instructions PAPI_SR_INS Store instructions PAPI_BR_INS Branch instructions PAPI_VEC_INS Vector/SIMD instructions PAPI_LST_INS Load/store instructions completed PAPI_SYC_INS Synchronization instructions completed PAPI_FML_INS Floating point multiply instructions PAPI_FAD_INS Floating point add instructions PAPI_FDV_INS Floating point divide instructions PAPI_FSQ_INS Floating point square root instructions PAPI_FNV_INS Floating point inverse instructions PAPI_RES_STL Cycles stalled on any resource PAPI_FP_STAL Cycles the FP unit(s) are stalled PAPI_FP_OPS Floating point operations PAPI_TOT_CYC Total cycles PAPI_HW_INT Hardware interrupts
Building VampirTrace is typically a combination of running configure
and
make. Execute the following commands to install VampirTrace from
within the directory at the top of the tree:
% ./configure --prefix=/where/to/install [...lots of output...] % make all install
If you need special access for installing, then you can execute make all as a user with write permissions in the build tree, and a separate make install as a user with write permissions to the install tree.
However, for more details, also read the following instructions. Sometimes it might be necessary to provide ./configure with options, e.g. specifications of paths or compilers. Please consult the CONFIG-EXAMPLES file to get an idea of how to configure VampirTrace for your platform.
VampirTrace comes with example programs written in C, C++, and Fortran. They can be used to test different instrumentation types of the VampirTrace installation. You can find them in the directory examples of the VampirTrace package.
Some systems require unusual options for compiling or linking that
the
configure script does not know about. Run ./configure -help
for details on some of the pertinent environment variables.
You can pass initial values for configuration parameters to configure by setting variables in the command line or in the environment. Here is an example:
% ./configure CC=c89 CFLAGS=-O2 LIBS=-lposix
By default, make install will install the package's files in /usr/local/bin, /usr/local/include, etc. You can specify an installation prefix other than /usr/local by giving configure the option -prefix=PATH.
If you would like to use an external version of OTF library, set:
If used OTF library was built without zlib support, then OTFLIB will be set to -lotf.
If you have not specified the environment variable MPICC (MPI compiler command), use the following options to set the location of your MPI installation:
Building VampirTrace on cross compilation platforms needs some special attention. The compiler wrappers and OPARI are built for the front-end (build system) whereas the VampirTrace libraries, vtdyn, vtunify, and vtfilter are built for the back-end (host system). Some configure options which are of interest for cross compilation are shown below:
% ./configure CC=sxcc CXX=sxc++ F77=sxf90 FC=sxf90 AR=sxar RANLIB="sxar st" CXX_FOR_BUILD=c++ --host=sx6-nec-superux14.1 --with-otf-lib=-lotf
Add the bin subdirectory of the installation directory to your
$PATH environment variable. To use VampirTrace with Dyninst,
you will also need to add the lib subdirectory to your
LD_LIBRARY_PATH environment variable:
for csh and tcsh:
> setenv PATH <vt-install>/bin:$PATH > setenv LD_LIBRARY_PATH <vt-install>/lib:$LD_LIBRARY_PATHfor bash and sh:
% export PATH=<vt-install>/bin:$PATH % export LD_LIBRARY_PATH=<vt-install>/lib:$LD_LIBRARY_PATH
If you have checked out a developer's copy of VampirTrace (i.e. checked out from CVS), you should first run:
% ./bootstrapNote that GNU Autoconf ≥2.60 and GNU Automake ≥1.9.6 is required. You can download them from http://www.gnu.org/software/autoconf and http://www.gnu.org/software/automake.
If you would like to create a new distribution tarball, run:
% ./makedist -o <otftarball> <major> <minor> <release>instead of make dist. The script makedist adapts the version number <major>.<minor>.<release> in configure.in and extracts given OTF-tarball <otftarball> in ./extlib/otf/.


Local Network Collaboration
(This feature is not available in Code Co-op Lite)
Planning LAN Collaboration
Here are things to remember when setting up network collaboration:
- You don't need a server. There is no central repository. Project data are replicated on each computer.
- You have to designate one computer on the LAN as a Hub for script distribution (it is not a server). All scripts on the network will be routed through the Hub.
- All other machines on the network are the satellites of this Hub
- The Hub may use email to communicate with other Hubs or with email peers
- A good choice for a Hub is a machine that is on most of the time
< Back Next: Coollaboration Wizard >


Generate Diary
2013/14
2014/15
2015/16
2016/17
2017/18
Start of school
End of school
Calendar
Week
Mon
Tue
Wed
Thu
Fri


--- layout: page title: "About" description: "Hey, this is Jane." header-img: "img/about-bg.jpg" ---
写写代码，做做设计，
离开世界之前，一切都是过程
Hey，我是Jane，程序员 & AUT学生党。
Yet another Web Developer.
Yet another Life-long Designer.
Hi, I am Jane Wang ,
an AUT student and a freelancer engineer who enjoy making amazing happened
(👉 Portfolio and Github),
you also can call me Jane.
I am enthusiastic to learn new technologies and willing to share things with others.
I graduated from Shijiazhuang Railway Institute , Computer school in July 2006, my major is computer science.
After that I worked in local Education Bureau in Information center department as a web master.
My routine was quite stable but dull. No challenge No pleasure.
I stayed in Malaysia for five years, from 2010-2015.
During this period I got my master degree in University of Malaya (UM) in 2013.
Malaysia is a pretty country, beautiful scenery, bright sunshine, delicious food and so on.
I am quite keen on this country. But I have to leave there.
I have a lovely daughter, her name is Angel.
Now she is 5-year old, in order to give a higher starting point,
I came to New Zealand, and doing my PHD degree in Auckland University of Technology (AUT) .
My research area is social context-aware.
I love New Zealand as well.
It can provide me with a good opportunity to breath new fresh area, and my daughter can enjoy her life in many place.
I enjoy turning complex problems into simple,
I am easy going ad talktive. I have a plenty of friends in NZ.
When I'm not coding you'll find me in the gym.


I'm currently a senior majoring in Computer Science: Digital Media Design, an interdisciplinary program of computer science and art, at the University of Pennsylvania. I am very interested in both, Software Development and Computer Graphics.
I drew comics and came up with my own "inventions" since I was 6, and this led me to be an imaginative/creative person who always thrive to come up with something new and unprecedented. In my free time I enjoy drawing, swimming, reading comics, and watching movies.
View ResumeA physically based animation simulation using Material-Point-Method and implicit and explicit Euler integration. Jello cubes animation is created using MPM in Taichi, and cloth mesh / volumetric 3D bunny model animation is simulated with Mass-Spring Euler integration in C++. These simulations are rendered using Houdini.
An errand service platform that connects students with school peers to ask for or do errands and create a tighter community. It allows the users to set errand details, such as time, importance, area etc. and chat with matches peers.
A Monte Carlo Path Tracer with global illumination effect using Monte Carlo estimation with multiple importance sampling. It supports various surface materials (diffuse, specular, transmissive, microfacet etc.), light sources (point, spot, area), and geometries.
A simple version of sandbox game, Minecraft. It includes procedurally generated terrain, rivers, and various biomes: mountains, fields, canyons etc. using Fractal Brownian Motion / Perlin noise functions and L-System.
A mini-Facebook web application, which supports user accounts, profiles, friend recommendations, and chatting service. It was developed focusing on utilizing cloud computing technologies to build a scalable application.
A rudimentary version of Autodesk Maya that supports various operations, such as vertex manipulation, edge split, face extrusion, and smoothing with Catmull-Clark subdivision. It allows loading OBJ and JSON files and 3D-mesh deformation by skinning skeleton.
If you have questions or
comments about my work..


This is the body section of our blog post. In this section I will write about whatever. I'll be sure to use the HTML tags I've been learning how to code.
This is another paragraph, and I would like to quote the late, great Martin Luther King Jr. who once said
I have a dream
.
I am happy to join with you today in what will go down in history as the greatest demonstration for freedom in the history of our nation.
Five score years ago, a great American, in whose symbolic shadow we stand today, signed the Emancipation Proclamation. This momentous decree came as a great beacon light of hope to millions of Negro slaves who had been seared in the flames of withering injustice. It came as a joyous daybreak to end the long night of their captivity.


closed
by Hector Correa at 2022-06-28 14:13:27.referenced
by Hector Correa at 2022-06-28 14:13:26.merged
by Hector Correa at 2022-06-28 14:13:27.closed
by Hector Correa at 2022-06-28 14:13:27.head_ref_deleted
by Hector Correa at 2022-06-28 15:54:47.assigned
by None at 2022-06-28 16:14:18.closed
by Jane Sandberg at 2022-06-28 22:49:36.review_requested
by None at 2022-06-28 16:54:45.convert_to_draft
by None at 2022-06-28 16:54:59.head_ref_force_pushed
by None at 2022-06-28 16:58:06.ready_for_review
by None at 2022-06-28 16:58:20.referenced
by Jane Sandberg at 2022-06-28 22:49:36.merged
by Jane Sandberg at 2022-06-28 22:49:36.closed
by Jane Sandberg at 2022-06-28 22:49:36.head_ref_deleted
by Jane Sandberg at 2022-06-28 22:49:37.closed
by Max Kadel at 2022-06-28 16:05:53.You want also to remove: https://github.com/pulibrary/bibdata/blob/main/spec/fixtures/marc_to_solr/overlap_20200316_compacted_sorted_final.tsv https://github.com/pulibrary/bibdata/blob/main/spec/fixtures/files/overlap_20200429_columbia_abbreviated.tsv https://github.com/pulibrary/bibdata/blob/main/spec/fixtures/overlap_20200429_princeton.tsv
Thanks - done
review_dismissed
by Max Kadel at 2022-06-28 12:51:40.referenced
by Max Kadel at 2022-06-28 16:05:53.merged
by Max Kadel at 2022-06-28 16:05:53.closed
by Max Kadel at 2022-06-28 16:05:53.head_ref_deleted
by Max Kadel at 2022-06-28 16:05:54.renamed
by Max Kadel at 2022-06-28 15:44:48.referenced
by Kevin Reiss at 2022-06-28 21:17:13.merged
by Kevin Reiss at 2022-06-28 21:17:14.closed
by Kevin Reiss at 2022-06-28 21:17:14.head_ref_deleted
by Kevin Reiss at 2022-06-28 21:17:14.referenced
by Christina Chortaria at 2022-06-28 11:47:57.merged
by Christina Chortaria at 2022-06-28 11:47:57.closed
by Christina Chortaria at 2022-06-28 11:47:57.head_ref_deleted
by Christina Chortaria at 2022-06-28 11:47:57.reopened
by James R. Griffin III at 2022-06-28 12:16:15.closed
by Bess Sadler at 2022-06-28 15:09:35.closed
by Bess Sadler at 2022-06-28 15:09:47.I looked at the object in figgy and checked the file manager. There was a file that didn't have derivatives. I used the "regenerate derivatives" button and derivatives generated. The link works now.
closed
by None at 2022-06-28 17:46:16.referenced
by None at 2022-06-28 17:50:51.merged
by None at 2022-06-28 17:50:51.closed
by None at 2022-06-28 17:50:51.head_ref_deleted
by None at 2022-06-28 17:50:52.deployed
by None at 2022-06-28 16:52:02.closed
by None at 2022-06-28 17:50:57.renamed
by None at 2022-06-28 17:57:10.renamed
by None at 2022-06-28 17:57:40.head_ref_force_pushed
by Eliot Jordan at 2022-06-28 16:21:21.deployed
by None at 2022-06-28 16:26:40.head_ref_force_pushed
by Eliot Jordan at 2022-06-28 19:35:14.deployed
by None at 2022-06-28 19:36:05.deployed
by None at 2022-06-28 20:03:54.labeled
by Eliot Jordan at 2022-06-28 20:11:34.assigned
by Eliot Jordan at 2022-06-28 20:11:35.assigned
by None at 2022-06-28 20:11:35.referenced
by Kevin Reiss at 2022-06-28 01:58:40.merged
by Kevin Reiss at 2022-06-28 01:58:40.closed
by Kevin Reiss at 2022-06-28 01:58:41.head_ref_deleted
by Kevin Reiss at 2022-06-28 01:58:41.because of the missing file /opt/lib-jobs/shared/staff-directory_20220624.csv
, error: Errno::ENOENT in rake lib_jobs:generate_staff_report --silent
was triggered with Honeybadger error: https://app.honeybadger.io/projects/100710/faults/86337710
convert_to_draft
by Jane Sandberg at 2022-06-28 21:43:49.This was set up with deny to the world originally. I'm unsure what the ticket is asking for: https://github.com/pulibrary/princeton_ansible/commit/05fd1534ade8b5e5883f2697bf22f37e22d1df5a#diff-d0222c7beedb8cf4c7ce1ec449f42d25abd70cfc1b9c0105057b17513560943aR42-R45 I was denied when I was not on VPN, and have access when on VPN
assigned
by None at 2022-06-28 04:35:10.unassigned
by None at 2022-06-28 04:38:31.Feedback from the PO so far:
Thanks so much! It looks like the Japanese font is where it is expected in relation to the English font. I am unable to tell if the font is completely correct (I'm not fluent in Japanese), but I told [library stakeholder] who will examine this closely with [other primary stakeholder]. They will let me know if anything appears incorrect and I will keep you posted.
closed
by Kate Lynch at 2022-06-28 15:30:08.head_ref_deleted
by Kate Lynch at 2022-06-28 15:30:36.closed
by Hector Correa at 2022-06-28 15:53:12.referenced
by Hector Correa at 2022-06-28 15:53:11.merged
by Hector Correa at 2022-06-28 15:53:12.closed
by Hector Correa at 2022-06-28 15:53:12.head_ref_deleted
by Hector Correa at 2022-06-28 15:53:13.referenced
by James R. Griffin III at 2022-06-28 19:26:20.merged
by James R. Griffin III at 2022-06-28 19:26:20.closed
by James R. Griffin III at 2022-06-28 19:26:20.head_ref_deleted
by James R. Griffin III at 2022-06-28 19:26:21.convert_to_draft
by Hector Correa at 2022-06-28 19:39:12.deployed
by None at 2022-06-28 19:39:42.ready_for_review
by Hector Correa at 2022-06-28 20:03:55.@bess I noticed this PR hanging around. I followed the instructions here: https://github.com/rails/webpacker/tree/5-x-stable and came up with https://github.com/pulibrary/pdc_discovery/tree/update-webpacker which seems to pass CI. Did you want me to open a new PR? It has a few additional updates, which may or may not be needed.
mentioned
by Bess Sadler at 2022-06-28 05:28:10.subscribed
by Bess Sadler at 2022-06-28 05:28:10.This ticket was prompted by a problem updating lib-jobs.princeton.edu in mid-June, after changing the playbook to run the ruby_s
role instead of the ruby
role. The playbook ran fine, but the first deploy after the playbook run failed. On investigation, it turned out there were multiple versions of ruby installed on the box. We suspect that the ruby version passenger was using was not the newly installed version. Gist of the run: https://gist.github.com/pulbot/ad1588075adb2d5bca178211089cdbfb
Related to #3114.
Notes from Ansible meeting 6/28: - for implementing this, try decoupling the directory changes from the code/config changes, to reduce the number of moving parts - turn off the workers while we update - take one box at a time off the load-balancer to update - see https://stackoverflow.com/a/66283091 for a potential approach to the directory renaming Thanks @sandbergja @hackartisan @maxkadel @stephayers !
mentioned
by None at 2022-06-28 17:07:36.subscribed
by None at 2022-06-28 17:07:36.mentioned
by Jane Sandberg at 2022-06-28 17:07:36.subscribed
by Jane Sandberg at 2022-06-28 17:07:36.mentioned
by Max Kadel at 2022-06-28 17:07:36.subscribed
by Max Kadel at 2022-06-28 17:07:36.mentioned
by None at 2022-06-28 17:07:36.subscribed
by None at 2022-06-28 17:07:36.head_ref_deleted
by Alicia Cozine at 2022-06-28 17:09:20.head_ref_deleted
by Alicia Cozine at 2022-06-28 17:09:25.Looks good, thanks @kayiwa
mentioned
by Francis Kayiwa at 2022-06-28 17:10:25.subscribed
by Francis Kayiwa at 2022-06-28 17:10:25.referenced
by Alicia Cozine at 2022-06-28 17:10:31.merged
by Alicia Cozine at 2022-06-28 17:10:31.closed
by Alicia Cozine at 2022-06-28 17:10:31.head_ref_deleted
by Alicia Cozine at 2022-06-28 17:10:32.head_ref_deleted
by Alicia Cozine at 2022-06-28 17:24:36.head_ref_deleted
by Alicia Cozine at 2022-06-28 17:24:39.referenced
by Alicia Cozine at 2022-06-28 21:01:27.merged
by Alicia Cozine at 2022-06-28 21:01:27.closed
by Alicia Cozine at 2022-06-28 21:01:27.head_ref_deleted
by Alicia Cozine at 2022-06-28 21:01:27.referenced
by Kevin Reiss at 2022-06-28 01:54:12.merged
by Kevin Reiss at 2022-06-28 01:54:12.closed
by Kevin Reiss at 2022-06-28 01:54:12.head_ref_deleted
by Kevin Reiss at 2022-06-28 01:54:13.I don't think this is a bad idea, but it would require node 12 (we are currently on 6)
Rough draft for layout and areas of info to cover (to be reviewed with RDSS at check-in) - https://docs.google.com/drawings/d/1A9OiJuzeBT5imPKDDaFKMR_ZJi1KRInJXliMJQIl2GE/edit
I would also utilize these instructions: https://github.com/pulibrary/researchdata/wiki/Upgrade-Drupal-core-via-Composer
The instructions here: https://github.com/pulibrary/researchdata/wiki/Upgrade-Drupal-core-via-Composer Indicate in step 4 to drop the changes.
referenced
by Kevin Reiss at 2022-06-28 01:56:12.merged
by Kevin Reiss at 2022-06-28 01:56:12.closed
by Kevin Reiss at 2022-06-28 01:56:12.head_ref_deleted
by Kevin Reiss at 2022-06-28 01:56:13.


The RGB color model is an additive color model in which red, green and blue light are added together in various ways to reproduce a broad array of colors... (wikipedia)


Traffic: 20k requests per minute
Impact: 20 customers per minute experience given latency or higher
If P99.9 drops to 2 seconds of latency,
40 minutes of customer time per hour wasted!
Is this impacting customers or is it a false alarm?
Is the problem cluster-wide or on a specific k8s node?
Are there any obvious saturation or errors?
Is it a utilization problem that can't be seen with rolling averages?
If a process is waiting on CPU time, why? Is it being throttled?
Utilization
Saturation
Errors
Processor
Memory
Network
Disk
/usr/bin/toolbox
Systems Performance, by Brendan Gregg
Linux Performance Analysis in 60 seconds (https://bit.ly/2ApDEC7)
The USE Method (https://bit.ly/2fPGEut)


Reconstructed photon matching a simulated photon:
Number of clusters outside moustache.
The distribution is for ecal barrel only.
|
Reconstructed photon matching a simulated photon.
Number of clusters outside moustache.
The distribution is for ecal endcaps only.
|
Conversion track pair reconstruction efficiency as a function of simulated &eta
|
Conversion track pair reconstruction efficiency as a function of simulated &phi
|
Conversion track pair reconstruction efficiency as a function of simulated conversion radius.
|
Conversion track pair reconstruction efficiency as a function of simulated z.
|
Conversion track pair reconstruction efficiency as a function of the true phohoton transverse energy.
|
Converted photon (i.e. with tracks) energy resolution defined as the ratio between reconstructed and simulated energy.
The distribution is obtained for |&eta| < 2.5
|
Converted photon (i.e. with tracks) energy resolution defined as the ratio between reconstructed and simulated energy.
The distribution is for ecal barrel only.
|
Converted photon (i.e. with tracks) energy resolution defined as the ratio between reconstructed and simulated energy.
The distribution is for ecal endcaps only.
|
Converted photon (i.e. with tracks) Pt resolution defined as the ratio between the transverse momentum reconstructed from the tracks and the simulated Et.
The distribution is obtained for |&eta| < 2.5
|
Converted photon (i.e. with tracks) Pt resolution defined as the ratio between the transverse momentum reconstructed from the tracks and the simulated Et.
The distribution is for ecal barrel only.
|
Converted photon (i.e. with tracks) Pt resolution defined as the ratio between the transverse momentum reconstructed from the tracks and the simulated Et.
The distribution is for ecal endcaps only.
|
Converted photon (i.e. with tracks) E/P. E is the super cluster energy, P is the momentum.
calculated from the track pair.
The distribution is obtained for |&eta| < 2.5
|
Converted photon (i.e. with tracks) E/P. E is the super cluster energy, P is the momentum.
The distribution is for ecal barrel only.
|
Converted photon (i.e. with tracks) E/P. E is the super cluster energy, P is the momentum.
The distribution is for ecal endcaps only.
|
Converted photon (i.e. with tracks) P/E. E is the super cluster energy, P is the momentum.
calculated from the track pair.
The distribution is obtained for |&eta| < 2.5
|
Converted photon (i.e. with tracks) P/E. E is the super cluster energy, P is the momentum.
The distribution is for ecal barrel only.
|
Converted photon (i.e. with tracks) P/E. E is the super cluster energy, P is the momentum.
The distribution is for ecal endcaps only.
|
Profile vs &eta of conversion energy resolution, defined as the ration between super cluster energy
and true energy.
|
Profile vs &eta of conversion E/P.
|
Profile vs true conversion radius of conversion E/P.
|


Phillip Eby posted another revision of the Web Server Gateway Interface (WSGI) spec, and it's pretty much ready to be proposed as a PEP and be discussed more widely.
So I was thinking about WSGI middleware (extending my previous thoughts). WSGI specifies a fairly simple interface between a "server" and an "application". The application in turn can be a server to another application; thus it would be middleware. It would be cool to implement Webware as a stack of such middleware: each piece would be small, easily understood and debugged; parts could be shared with others (or taken from other projects); smaller pieces are easier to understand, and the code flow is very specific. If I was to take everything Webware does now and turn it into these middleware components, this is what I think I'd get:
1. The AppServer. This is a threaded server that accepts connections (both a special FastCGI-like protocol and HTTP), spawns a thread for the request, and passes the request on.
2. Configuration handler. I don't know exactly where this comes in, but I want to configure all these pieces together, but also include URL-specific configuration. So the configuration has to be involved in this chain of middleware.
3. An exception catcher. This will catch any exceptions in the application, log them, email them, provide post-mortem debugging information, display a pretty traceback, etc.
4. A session handler. This will look for any session variables, and create a session object if needed. It will put the session object in the environ dictionary (webkit.session).
5. A URL parser/resource finder. This is URLParser in Webware CVS. It looks on the disk to find a file (as well as looking at other hooks). Once it finds a file or some resource, it finds a factory (based on extension or some other metadata) and uses the factory to create an application.
6. A ServletFactory which talks WSGI. This moves things like the creation of HTTPRequest further back in the process.
The interesting part of this is that a lot of this isn't very Webware-specific at all. Step 6 is very specific to Webware, but the rest isn't. Pieces can also be swapped out. For instance, I'd actually like to change this, as I think Webware spawns a thread too early -- I suspect threads and sockets interact poorly on some platforms, causing the occasional lockup. Redhat and FreeBSD seem to have problems. So I'd swap out #1 for:
1a. An async server. Either Medusa or Twisted. Medusa is smaller, Twisted better; once the Twisted stuff I'm interested is available separately (which is planned), then it would probably be an easier choice.
1b. A threading middleware. It takes the async request that 1a generates, and uses a threadpool to make it multithreaded, handling whatever buffering or interaction it needs to do.
There's other pieces that can be recombined. For instance, the URLParser could redirect the request to any WSGI application, not just Webware servlets. The exception catcher could be developed separately, and should work just fine with any stack. Each piece could reasonably have multiple implementations. This seems like a good way to compose a framework.
And, don't forget that WebWare users would also be able to switch out 1, 1a, and 1b for something else altogether, like mod_python or PEAK's FastCGI runner, once they support WSGI.
Of course, that's assuming that the other pieces in your stack support a multi-process execution model as well as the single process, multi-thread modes. But even if they don't, the web server can be any single-process multi-thread WSGI server or gateway.
# Phillip J. Eby
Webware stuff generally expects a single-process, multi-threaded model. But most of those things could be made neutral, though there are a lot of Webware applications that assume a multi-threaded environment (e.g., they store global information in global variables).# Ian Bicking
The python threading model is broken, it's about time we fix it:
http://www.usingcsp.com
(I know that stackless implements part of the csp model, but stackless has lots of other stuff I don't want, and stackless is not CPython that is what I want to use)# Uriel


(H1) Everything you need (client main color)
With a wide range of excellent creative from banner adverts to videos, special offers to free online psychic chats the LifeReader affiliate program has everything you need to start earning big commissions online!
Our psychic affiliate program allows you to refer new customers to us and when they use the LifeReader website on desktop, laptop, tablet or mobile to access top-rated psychics for readings via text chat or phone we will pay you a very generous commission.
(H2) Program highlights
- Up to $200 commission for each new customer
- 100 day cookie period
- No leakage - everything is tracked, from online chat to phone readings
- Frequently updated creative in a range of designs - and the ability to do custom creatives
- We accept affiliates worldwide, including international websites
How does it work
Affiliate marketing is when an advertiser (in this case LifeReader) pays a commission to an individual, company or website owner for referring a new customer. Everything is tracked using one of our affiliate network partners in real time and you can see how much money you have made in their online interface.
Simply click below to apply to your preferred affiliate program depending on where you are located in the world.
Once your application is approved (usually between 1 and 24 hours), we'll send you links, banners and other creatives that you can immediately use on your website, emails, mobile apps, social networks or any other digital assets you may have.
Simply click below to apply to your preferred affiliate program depending on where you are located in the world.
Once your application is approved (usually between 1 and 24 hours), we'll send you links, banners and other creatives that you can immediately use on your website, emails, mobile apps, social networks or any other digital assets you may have.
Simply click below to apply to your preferred affiliate program depending on where you are located in the world.
Once your application is approved (usually between 1 and 24 hours), we'll send you links, banners and other creatives that you can immediately use on your website, emails, mobile apps, social networks or any other digital assets you may have.


PIZZA-HOUSE
Size
Crust
Meat
Quantity
confirm Order
Cart
Total Order: Ksh
Checkout
Order summary
Your order is:
Home Delivery?
Delivery services
Enter your name
Enter your location
Enter your phone number
Submit>


{{recipe.title}}
{{recipe.description[:250]}}... Read more
{% extends "user/base.html" %} {% block content %}
Share your story through your dishes to our community of Food enthusiasts. Onion provides a variety of support from selling your homemade ingredients to finding your dream job by creating a public portfolio for Chefs
There are no recipe contributors at this moment.
{% endif %}There are no featured recipe at this moment
{% endfor %} {% endif %}


WITNESS LIST Licensing & Administrative Procedures Committee April 6, 2005-8:00A HB 2243 - Committee Substitute (D. Jones/CSHB 2243) For: Smith, Steve (Self and Texas Towing & Storage Association) HB 2438 - Committee Substitute (D. Jones/CSHB 2438) For: Anderson, Jody (Self and Texas Manufactured Housing Association) Against: Caraway, Luanne (Tax Assessor-Collector Association) Garrett, Rovin (Tax Assessor Collectors Assn. of Texas)


Check out the tools available in the nav-bar above.
Enabling Demo Mode will load preset demonstration values in all tools.
You are running not running under Electron. Please download the Desktop Client if you want to use any of the Electron-powered tools.
You are running under Electron.
Scan Tools(Local Scan/D-Scan): Copy from the Local window or D-Scan and paste it into the parser to get a composition breakdown. Works exactly like other EVE parsing tools except all requests and processing are made client-side, without a back-end server. Without centralized caching provided by a back-end, parsing is slower, but you keep full control over your data.
Market Browser: Quickly look up prices for items across any region in the game without having to login.
Zkill Listener: Listens for killmails on the zKillboard Live Feed as they come in, you can filter by alliance, corporation, location, ship-type and enable sound notifications.
Navigation: Quick-reference tools to check Jump-Distance, determine which systems are in range, or calculate gate routes with preference settings.
Profile Sync(Desktop-Only): Sync your EVE settings between accounts or characters. Very useful for anyone managing multiple accounts. Backups are made automatically before syncing to ensure your profiles stay safe.
VNI Companion(Desktop-Only): Multiple tools that enable safer and easier Ratting. Watches an Intel channel for activity in systems near you. Alerts for faction and capital spawns. Counts how much ISK you've accumulated during your Ratting session.


Limerick Release Statement As Two Players Sent Home From New York
by Michael CorryLimerick GAA have released a statement confirming that two players have been sent home from their trip to New York.
The 2018 All-Ireland champions were taking part in the now annual Super 11s at Citifield, the home of Major League Baseball outfit, the New York Mets.
Limerick qualified for the final of the tournament after defeating Wexford in the semi-final before falling to Kilkenny in the final.
Following the event, video footage circulated of a member of the Limerick panel fighting with a person on the streets of New York.
The video footage circulated far and wide and now the county board have released a statement confirming that those involved have been sent home.
“Limerick GAA can confirm it sent home two panellists early from last weekend’s New York Hurling Classic following an incident.
“Limerick GAA expects the highest standards of behaviour and example from its players, both on and off the field, and will not tolerate any breach of those standards.
“A disciplinary process has commenced and there will be no further comment in relation to this matter.”


This tutorial focuses on the boto interface to the Autoscale service. This assumes you are familiar with boto’s EC2 interface and concepts.
The AWS Autoscale service is comprised of three core concepts:
- Autoscale Group (AG): An AG can be viewed as a collection of criteria for maintaining or scaling a set of EC2 instances over one or more availability zones. An AG is limited to a single region.
- Launch Configuration (LC): An LC is the set of information needed by the AG to launch new instances - this can encompass image ids, startup data, security groups and keys. Only one LC is attached to an AG.
- Triggers: A trigger is essentially a set of rules for determining when to scale an AG up or down. These rules can encompass a set of metrics such as average CPU usage across instances, or incoming requests, a threshold for when an action will take place, as well as parameters to control how long to wait after a threshold is crossed.
The first step in accessing autoscaling is to create a connection to the service. There are two ways to do this in boto. The first is:
>>> from boto.ec2.autoscale import AutoScaleConnection
>>> conn = AutoScaleConnection('<aws access key>', '<aws secret key>')
Like EC2 the Autoscale service has a different endpoint for each region. By default the US endpoint is used. To choose a specific region, instantiate the AutoScaleConnection object with that region’s endpoint.
>>> import boto.ec2.autoscale
>>> autoscale = boto.ec2.autoscale.connect_to_region('eu-west-1')
Alternatively, edit your boto.cfg with the default Autoscale endpoint to use:
[Boto]
autoscale_endpoint = autoscaling.eu-west-1.amazonaws.com
To retrieve existing autoscale groups:
>>> conn.get_all_groups()
You will get back a list of AutoScale group objects, one for each AG you have.
An Autoscaling group has a number of parameters associated with it.
- Name: The name of the AG.
- Availability Zones: The list of availability zones it is defined over.
- Minimum Size: Minimum number of instances running at one time.
- Maximum Size: Maximum number of instances running at one time.
- Launch Configuration (LC): A set of instructions on how to launch an instance.
- Load Balancer: An optional ELB load balancer to use. See the ELB tutorial for information on how to create a load balancer.
For the purposes of this tutorial, let’s assume we want to create one autoscale group over the us-east-1a and us-east-1b availability zones. We want to have two instances in each availability zone, thus a minimum size of 4. For now we won’t worry about scaling up or down - we’ll introduce that later when we talk about triggers. Thus we’ll set a maximum size of 4 as well. We’ll also associate the AG with a load balancer which we assume we’ve already created, called ‘my_lb’.
Our LC tells us how to start an instance. This will at least include the image id to use, security_group, and key information. We assume the image id, key name and security groups have already been defined elsewhere - see the EC2 tutorial for information on how to create these.
>>> from boto.ec2.autoscale import LaunchConfiguration
>>> from boto.ec2.autoscale import AutoScalingGroup
>>> lc = LaunchConfiguration(name='my-launch_config', image_id='my-ami',
key_name='my_key_name',
security_groups=['my_security_groups'])
>>> conn.create_launch_configuration(lc)
We now have created a launch configuration called ‘my-launch-config’. We are now ready to associate it with our new autoscale group.
>>> ag = AutoScalingGroup(group_name='my_group', load_balancers=['my-lb'],
availability_zones=['us-east-1a', 'us-east-1b'],
launch_config=lc, min_size=4, max_size=8,
connection=conn)
>>> conn.create_auto_scaling_group(ag)
We now have a new autoscaling group defined! At this point instances should be starting to launch. To view activity on an autoscale group:
>>> ag.get_activities()
[Activity:Launching a new EC2 instance status:Successful progress:100,
...]
or alternatively:
>>> conn.get_all_activities(ag)
This autoscale group is fairly useful in that it will maintain the minimum size without breaching the maximum size defined. That means if one instance crashes, the autoscale group will use the launch configuration to start a new one in an attempt to maintain its minimum defined size. It knows instance health using the health check defined on its associated load balancer.
It can also be useful to scale a group up or down depending on certain criteria. For example, if the average CPU utilization of the group goes above 70%, you may want to scale up the number of instances to deal with demand. Likewise, you might want to scale down if usage drops again. These rules for how to scale are defined by Scaling Policies, and the rules for when to scale are defined by CloudWatch Metric Alarms.
For example, let’s configure scaling for the above group based on CPU utilization. We’ll say it should scale up if the average CPU usage goes above 70% and scale down if it goes below 40%.
Firstly, define some Scaling Policies. These tell Auto Scaling how to scale the group (but not when to do it, we’ll specify that later).
We need one policy for scaling up and one for scaling down.
>>> from boto.ec2.autoscale import ScalingPolicy
>>> scale_up_policy = ScalingPolicy(
name='scale_up', adjustment_type='ChangeInCapacity',
as_name='my_group', scaling_adjustment=1, cooldown=180)
>>> scale_down_policy = ScalingPolicy(
name='scale_down', adjustment_type='ChangeInCapacity',
as_name='my_group', scaling_adjustment=-1, cooldown=180)
The policy objects are now defined locally. Let’s submit them to AWS.
>>> conn.create_scaling_policy(scale_up_policy)
>>> conn.create_scaling_policy(scale_down_policy)
Now that the polices have been digested by AWS, they have extra properties that we aren’t aware of locally. We need to refresh them by requesting them back again.
>>> scale_up_policy = conn.get_all_policies(
as_group='my_group', policy_names=['scale_up'])[0]
>>> scale_down_policy = conn.get_all_policies(
as_group='my_group', policy_names=['scale_down'])[0]
Specifically, we’ll need the Amazon Resource Name (ARN) of each policy, which will now be a property of our ScalingPolicy objects.
Next we’ll create CloudWatch alarms that will define when to run the Auto Scaling Policies.
>>> import boto.ec2.cloudwatch
>>> cloudwatch = boto.ec2.cloudwatch.connect_to_region('us-west-2')
It makes sense to measure the average CPU usage across the whole Auto Scaling Group, rather than individual instances. We express that as CloudWatch Dimensions.
>>> alarm_dimensions = {"AutoScalingGroupName": 'my_group'}
Create an alarm for when to scale up, and one for when to scale down.
>>> from boto.ec2.cloudwatch import MetricAlarm
>>> scale_up_alarm = MetricAlarm(
name='scale_up_on_cpu', namespace='AWS/EC2',
metric='CPUUtilization', statistic='Average',
comparison='>', threshold='70',
period='60', evaluation_periods=2,
alarm_actions=[scale_up_policy.policy_arn],
dimensions=alarm_dimensions)
>>> cloudwatch.create_alarm(scale_up_alarm)
>>> scale_down_alarm = MetricAlarm(
name='scale_down_on_cpu', namespace='AWS/EC2',
metric='CPUUtilization', statistic='Average',
comparison='<', threshold='40',
period='60', evaluation_periods=2,
alarm_actions=[scale_down_policy.policy_arn],
dimensions=alarm_dimensions)
>>> cloudwatch.create_alarm(scale_down_alarm)
Auto Scaling will now create a new instance if the existing cluster averages more than 70% CPU for two minutes. Similarly, it will terminate an instance when CPU usage sits below 40%. Auto Scaling will not add or remove instances beyond the limits of the Scaling Group’s ‘max_size’ and ‘min_size’ properties.
To retrieve the instances in your autoscale group:
>>> import boto.ec2
>>> ec2 = boto.ec2.connect_to_region('us-west-2)
>>> group = conn.get_all_groups(names=['my_group'])[0]
>>> instance_ids = [i.instance_id for i in group.instances]
>>> instances = ec2.get_only_instances(instance_ids)
To delete your autoscale group, we first need to shutdown all the instances:
>>> ag.shutdown_instances()
Once the instances have been shutdown, you can delete the autoscale group:
>>> ag.delete()
You can also delete your launch configuration:
>>> lc.delete()


About-US
Education liberates the intellect, unlocks the imagination and is fundamental for self-respect.
It is the key to prosperity and opens a world of opportunities, making it possible for each of us to contribute to a progressive, healthy society.
Learning benefits every human being and should be available to all.
Our Vision:
Together we can ensure inclusive and equitable quality. Here you can see what you can do to contribute. Find organizations to support, information to share and some useful tips for your everyday life that can really make a difference.
EDUCATION FOR SUSTAINABLE
DEVELOPMENT AND GLOBAL CITIZENSHIP
By 2030, ensure that all learners acquire the knowledge and skills needed to promote sustainable development, including, among others, through education for sustainable development and sustainable lifestyles, human rights, gender equality, promotion of a culture of peace and non-violence, global citizenship and appreciation of cultural diversity and of culture’s contribution to sustainable development.


This introduction includes HTML, CSS, JavaScript and Angular.
This is non-special paragraph.
A special paragraph.


Ontimize Web Appearance is web application that shows a form configured with three different appearances supported by Angular Material:
Please refer to our changelog for up-to-date listings of all improvements and breaking changes.
Here are some interesting reading topics that can help you better understand how to develop with Ontimize Web.
The mat-form-field supports differents appearance variants which can be set via the appearance input.
In order to style your own components with Angular Material's tooling, the component's styles must be defined with Sass.
Guide to desing your own components with Lite Theme.


This example uses three different types of updaters.
HtmlUpdater inserts <script> tag in this HTML document to use WebExtension features.
XmlUpdater inserts a custom message into the XML document returned from server.
(Original message is "Hello from XML", but "updated by XmlUpdater" is added)
JsonUpdater inserts a custom message into the JSON from server.
(Original message is "Hello from JSON", but "updated by JsonUpdater" is added)


Create an elegant product list using Bootstrap 4 list group
Snippet by
Bootstrapious
Edit Profile
Personal info
First name:
Last name:
Phone:
Email:
Password:
Update Profile