text:
Thirty-month Postdoctoral Research Fellow in Energy-efficient Computing at UiT The Arctic University of Norway, Department of Computer Science.
Application deadline: Aug. 28, 2016
The Department of Computer Science at University of Tromsø – The Arctic University of Norway (UiT) has a Postdoctoral Research Fellow position vacant.
The position of Postdoctoral Research Fellow is a fixed term position for a period of thirty months. The primary objective of the appointment is for the research fellow to qualify for work in senior academic positions.
The position is attached to the Arctic Green Computing (AGC) research group at the Department of Computer Science.
Further information about the position is available by contacting associate professor Phuong H. Ha, phone +47 77 64 40 32, email: email@example.com
For administrative questions, please contact the Department's administration;
phone +47 77 64 40 36, email: firstname.lastname@example.com.
The position's affiliation
UiT The Arctic University of Norway is the largest research and educational institution in northern Norway with about 12,000 students and 2,900 employees. UiT is a founding member of the University of the Arctic, an international network of study and research institutions of the circumpolar region. Two hundred international agreements secure an active academic exchange of students and staff with partner institutions worldwide.
The Department of Computer Science provides a strong international research environment with 12 tenured faculty members, 6 adjunct professors, 3 post-doctors and researchers, 6 technical/administrative staff members and about 20 PhD students from different countries. The goal of the Department is to advance the research and teaching of Computer Science as a discipline, to demonstrate leadership within our areas of interest, and to contribute to society through our education, research and dissemination.
The Arctic Green Computing (AGC) research group aims at addressing energy efficiency, system complexity and dependability across mobile, embedded and data-center systems. The group current research interests include novel execution models forming foundations for a paradigm shift from energy "blind" to energy "aware" software development and, at the same time, facilitating programming productivity on energy-efficient computing systems. The group research has been funded by European Commission (FP7), Norwegian Research Council (FRIPRO) and UiT. The group is a work-package leader in EU FP7 ICT project EXCESS on energy-efficient high-performance computing systems (2013 – 2016) and the project leader of Norwegian FRIPRO project PREAPP on programming productivity and energy efficiency (2014 – 2019). The group is the Norwegian representative in the management committee of the EU COST Action Euro-TM on concurrent programming abstractions (2011 – 2015) and a member of EU network of excellence HiPEAC on high performance and embedded architecture and compilation.
The position's field of research/field of work
In today's exponential world of digital data, computing technology plays an essential role in addressing our major social challenges including climate change, health, energy and education. However, worldwide computing systems currently consume 30 billion watts, equivalent to the output of 30 large nuclear power plants. The environmental impact of computing systems is of the same order as that of the Czech Republic, the 35th country in the top carbon-emitting countries in the world. Energy efficiency is therefore considered a major criterion for "sustainable" computing systems and services over the data deluge. However, energy-efficient computing systems make parallel programming even more complex and thereby less robust due to requirements of massive parallelism, heterogeneity and data locality.
The research project aims at devising novel programming models that will form foundations for a paradigm shift from energy "blind" to energy "aware" software development. The new models will enable significant improvement in energy efficiency in comparison with today's multicore computing, thereby greatly advancing green computing and sustainable services. The new models will facilitate unprecedented productivity for implementing scientific big data applications that run effectively on large-scale high-performance computing (HPC) platforms, which are based on cutting-edge manycore architectures. The threshold of adopting large-scale parallel computing will thus be considerably lowered for a large number of computational scientists in several disciplines.
Qualification requirements
The successful candidate will have a publication record that documents solid knowledge in computer science, and strong research skills on technical aspects of experimental computer science. We are looking for candidates who have demonstrated increased scientific maturity in their selection of issues, application of methods, and documentation of results. Research results should be backed by thorough experiments and analysis.
For appointment as Postdoctoral Fellow, the applicant requires:
- Norwegian doctoral degree in the subject area concerned or a corresponding foreign doctoral degree recognized as equivalent to a Norwegian doctoral degree.
When applying for a Postdoctoral Research Fellowship, the applicant shall submit a project proposal for the qualifying work. This proposal shall include a progress plan. It is required that the applicant will be able to complete the project during the period of appointment.
The successful candidate should have a strong interest in at least one of the following topics: energy-efficient computing, concurrent data structures and algorithms, programming systems, run-time systems and big data processing. Experience of partitioned global address space (PGAS) programming and convolutional neural network (CNN) is a plus.
Emphasis shall be attached to personal suitability.
Working conditions
The working hours shall primarily be utilized for research, research-related activities and research administration. The position will not include regular teaching assignments.
The successful applicant must be willing to engage himself/herself in the ongoing development of computer science as a discipline, the department, and of the university as a whole.
The remuneration for this position is in accordance with the State salary scale code 1352, grade range 57 – 77. At present, the gross salary starts from NOK 483,400 per year, depending on qualifications. A compulsory contribution of 2 % to the Norwegian Public Service Pension Fund will be deducted. We offer good welfare benefits.
Applicants are welcome to send an email to firstname.lastname@example.com. The e-mail ought to include the following email subject and PDF files:
- Email subject containing the applicant's full name
- Letter of application
- CV (containing a complete overview of education, supervised professional training and professional work)
- Research proposal
- List of publications
- Relevant publications: the applicant should submit up to ten publications that are central to his/her production. The applicant's doctoral thesis is regarded in this context as one publication.
- Description of his/her production stating which publications he/she considers the most important. A brief description of the other listed publications should also be included to demonstrate depth of production.
- Diplomas and transcripts from PhD degree or equivalent
- Names and email addresses of three references
All documentation should be translated into English or a Scandinavian language.
Well-qualified applicants will be called for an interview. Such an interview shall among other things aim to clarify the applicant's personal suitability for the position. A trial lecture may also be held.
Applicants should also refer to the Supplementary regulations for appointment to postdoktor (Postdoctoral Research Rellow), stipendiat (PhD) and vitenskapelig assistent (Research Assistant) positions at the University of Tromsø and to the Regulations concerning terms and conditions of employment for posts of postdoktor (Postdoctoral Research Fellow), stipendiat (PhD), vitenskapelig assistent (Research Assistant) and spesialistkandidat (Resident).
Questions concerning the organization of the working environment, such as the physical state of the place of employment, health service, possibility for flexible working hours, part time, etc. may be directed to the telephone reference in this announcement.
UiT has HR policy objectives that emphasize diversity, and therefore encourages qualified applicants to apply regardless of their age, gender, functional ability and national or ethnic background.
UiT is an IW (Inclusive Workplace) enterprise, and therefore emphasizes making the necessary adaptations to the working conditions for employees with reduced functional ability.


text:
Panelists are full participants in the meeting. They can view and send video, screen share, annotate, etc.
With the Webinar 100 plan, you can have up to 100 panelists including the host. With all other plans, you can have up to 300 panelists (including the host) in a webinar. This is different than attendees who are view-only participants who can be unmuted.
You can also promote an attendee to a panelist during a webinar.
This article covers:
- Webinar plan of 100, 500, 1000, 3000, 5000, or 10000 participants
- Registration webinar or registrationless webinar scheduled
How to add a panelist to a webinar
You can invite a person or Zoom Room to be a webinar panelist.
- Sign in to the Zoom web portal.
- Click Webinars.
- Click the topic of the webinar you want to add panelists to.
- In the Invitations tab, select the Edit button in the Invite panelists section.
- Enter a name and email address to invite them. If you're inviting a Zoom Room, enter the room name. The room's location will display in the Email/Zoom Rooms column.
- Select Add Another Panelist to add more panelists. Press Save to send invites to the new panelists entered.
- You can add up to 300 panelists, depending on meeting capacity
- You can delete and add panelists any time prior to the Webinar
- If you checked Send Invitation Email to Panelists Immediately, they will be sent an email invitation after you click Save.
Recurring webinars
If a webinar is recurring, the user will be a panelist for all webinars in that series. If you want them to join as a panelist for one webinar occurrence only, you will need to add them as a panelist before the webinar that you want them to be a panelist for and remove them before the next occurrence.
Removing a panelist
- Sign in to the Zoom web portal.
- Click Webinars.
- Click the topic of the webinar you need to remove panelists from.
- Select the Edit button in the Panelist section.
- Next to the panelist's name, click Delete.
- Click Save.
This panelist will now be removed from all webinars in the series and will need to join as an attendee.

subset: commoncrawl


text:
We are gradually working through all the antibody companies that have provided us with data and writing highlight pieces about them. If we have not got to you yet and you would like us to highlight your company then please get in touch.
We are also happy to highlight scientific conferences, websites and news items which are likely to be of interest to CiteAb users.


text:
Hey, we use cookies. Learn more about our cookies policy.
You have to know the characters from Frozen fairy tale. This time, the you'll take the roles of Olaf and Anna, who want to save their beloved Elsa. It's a moment to take on such a challenge and due to the cooperation easily finish them. Check to see if you can face with the icy environment and, together with a colleague or friend to collect the right amount of hearts and bonuses. Do your best! Pleasant, fairytale atmosphere will be great entertainment for boys, for girls, and especially for children. Feel the chill on your skin and move thanks to wonderful imagination, to the fantasy world with climate heroes!


text:
Jon Ronson is a writer and documentary film maker. His book, Them: Adventures With Extremists, was an international bestseller. His new book, The Men Who Stare At Goats in now available in the US in hardback. He grew up in Cardiff and began his journalistic career as an award-winning columnist for Time Out. He also wrote the popular "Human Zoo" column for The Guardian and produced the BBC Radio 4 documentary Hotel Auschwitz. He also presents the late night Radio 4 series, Jon Ronson on...
For Channel 4, Jon has made the acclaimed five part series the Secret Rulers of the World, multi award-winning Tottenham Ayatollah, New Klan, New York to California (A Great British Odyssey), Dr Paisley, I Presume, the four-part series Critical Condition, and the late-night chat show For The Love Of... For BBC2 he made the six part series The Ronson Mission. In the US, he is a contributor to National Public Radio's All Things Considered and This American Life.
Past shows:
Experiments & Conspiracies
Documentary film maker and author, Jon Ronson spoke about his investigation into the US military's strange experiments with the paranormal. At the "Goat Lab," tests were made to see if people could kill animals by simply staring at them. One man, Guy Savelli, who Ronson... More »


text:
About Us
Providing quality business services since 1993 for clients in the Western Massachusetts area.
All services are delivered with integrity, reliability and accuracy and assure all clients a long-term trusting relationship. My clients have described me as being a trustworthy individual who takes on any task put in front of them and gets it done with detail and accuracy. As an individual, I am able to provide my clients with services which include:
Administrative Services ~ Bookkeeping Services ~ Tax Preparation ~ Graphic Design ~ Web Design ~ IT Services ~ On-site and off-site Services


text:
*Credit is subject to status and application.
Double Glazing Ferguslie Park.The Advanced Group Windows & Doors are the top rated Double Glazing and Triple Glazing experts within the UK.
Investing in Double & Triple Glazed windows & doors at home can be one of the best investments you possibly can make both in enhancing the price of your home in addition to making your house far more energy efficient. This specific investment can certainly both make you money and even save you money delivering amazing benefit.
Never assume all upvc double glazing is made equal and the majority of people today are convinced merely to have double gazing ensures they are enjoying the full benefits.
Double Glazing Ferguslie Park. Today's high energy efficiency Double and Triple Glazed doors & windows are steps ahead of older double glazed window units. They will perform a lot better in all ways truly making a real difference in all kinds of homes.
Here at The Advanced Group we produce all of our Double Glazed window units in our manufacturing facility making sure that all Triple Glazed window orders are professionally built to order and bespoke to suit your property. The Advanced Group Windows have hundreds of different styles, features, colours and glazing options to help you pick the perfect glazing choice for your property.
The fact that we build all of our Double & Triple Glazed windows ensures that we can continually be extremely competitive in price without compromise on the quality of the Double & Triple Glazed Windows we make. Double Glazing Ferguslie Park. Double & Triple Glazed Windows options incorporate the many standard designs which include Casement Windows, Tilt & Turn, Sash Windows and Conservatories etc.
The Advanced Group are here right now to assist you in finding the appropriate windows, doors and conservatories for your home.
Call now to talk with our experts and to benefit from a FREE home survey by our specialist Glazing Team. Double Glazing Ferguslie Park.
If you need the best quality Triple Glazed Windows at the most competitive prices then phone The Advanced Group Today on 08000 502 502 to have a FREE no obligation quote.


text:
6-18-10 PNC Park
I had the opportunity to watch batting practice on the field today. I had to be in the Pirates administrative offices at 4:15, where I would receive a lanyard and Suite tickets for tonight's game.
However, the downfall of this opportunity is that the participants must stay in a small 15×15 area or so in center field. So snagging balls isn't that easy.
Game: 8 balls (4 hit, 2 thrown, 1 device, 1 found)
Season: 234 balls (126 hit, 59 thrown, 22 device, 27 found)
Games: 36 games
Average: 6.50 balls per game
2010 Game Balls: 3
Career: 812 balls
Streak: 132 consecutive games attended with at least 1 ball snagged.
Attendance: 28,478


text:
The 2011 FIFA Women's World Cup kicks off today in Germany. In September 2010, photographer Adrienne Grunwald, along with gender researcher and former Santos F.C. player Caitlin Fisher, began documenting the lives of forty female futebol players in Brazil who play professionally for Santos FC—one of the most renowned male futebol clubs of all time. Several members of the Santos team are representing their country on the Brazilian National team at this year's World Cup. Guerreiras (Female Warriors) explores changing gender norms among Brazil's professional female futebol players.
Futebol has long been considered Brazil's most popular sport and around the world, Brazil is regarded as "football country." These labels tend to refer solely to the men's game. The same machismo responsible for the prohibition of women's football during the country's military dictatorship from 1964-1981 carried over into the 21st century, creating social stigmas and cultural resistance to the women's game. Because of this legacy, female futebol players have continuously struggled to gain acceptance. These players have not only represented a threat to Brazilian masculinity, but have also been perceived as encroaching in a disgraceful manner on one of the nation's primary sources of pride and collective identity.
Recently, a shift has begun to unfold allowing the women's game to begin occupying a much more valued position within the culture—a shift that appears to be occurring hand-in-hand with Brazil's emergence in the global economy. Female players are stepping onto the field, carving a space for themselves and enjoying increased media attention, improved facilities, higher salaries—and for some female players, their individual struggles have been eased. Although there is still a long way to go towards equality in Brazilian women's futebol, this movement is arguably loosening the grips of machismo, contributing to the deconstruction of traditional gender roles, and serving as a strong source of empowerment.
— Caitlin Fisher and Adrienne Grunwald
Adrienne Grunwald is a freelance photographer based in New York City. To see more of Adrienne's work, visit her website.


text:
Our unique background in both project management and design qualifies us as an industry leader in modern construction solutions. We specialise in inherently complex infrastructure projects which include the diverse needs of multiple stakeholders, tight delivery time frames and/or budgetary constraints.
Sensum consists of an agile team of highly motivated and experienced staff dedicated to providing a unique and personalised project management service to our clients. Our collaborative team brings a wealth of varied perspectives and construction knowledge through trade, commercial construction, property development, and business administration backgrounds.
We think and work with an emphasis on collaboration and proactivity and as such, our tailored solutions are formulated along with our clients and are executed with transparent communication as our main priority. Our attention to detail and exceptional level of service ensures seamless co-ordination of our projects to achieve the best value for our clients. And throughout the process, we ensure that they are kept up-to-date with financial and program status and performance against the overall project objectives.
We are driven to provide superior customer service and successful delivery of all projects through regular and effective communication, periodic reporting and whole-of-project reviews. From the project outset, Sensum engages and consults with all project stakeholders. Regular operations meetings ensure that goals are achieved and informed by consultation and collaborative decision making. We co-ordinate meetings with contractors and stakeholders to review issues and risks particular to the project and factor these into the budget and program.


text:
The data we present below can be striking and certainly should be subject of analysis in the Companies.
It is estimated that only 3% of the electricity consumed in a Data Center, is actually used to process information, the rest is wasted in redundancy and inactivity. So that 97% of electricity is not leveraged.
Information Technology Systems represent 10% of electricity consumption in United Kingdom, and Datacenters have multiplied by 5 its consumption in the last 5 years.
The electricity consumption in Data Centers increases a 12% each year and is estimated that, at present times, it supposes 2% of total electricity consumption in the United States. It is similar to that in the aviation industry.
This country was pioneer in this aspect and It has worked since 1992 with the birth of the directive «Energy Star» for using technology and delivery models that would reduce the impact of generation, transmission and processing of information in the environment.
The growing institutional pressure in reduction of CO2 emissions today, has highlighted the role of IT in contributing to this ecological mission.
However, according to research, Green IT is not considered nowadays among the 10 strategic priorities of Spanish CIOs . The green projects are not priorities, products and service are not taken into account and therefore its benefits are not valued.
About 85% of IT departments do not know their pollution levels and 20% are not aware about the electricity costs that systems bring to the P&L.
Doubtless, there is great effort ahead by companies selling IT to convince ant to implement Green IT strategies.
Here, the concept of Cloud Computing and Software as a Service (SaaS) aims to unite to the advantages of lower costs, those derived from the contribution to sustainability, given that they are built up on virtualization infrastructures, sharing of resources ( Datacenters) policies and flexible provision of services as major arguments in support of that goal.
Only time will confirm us whether cloud computing models will eventually be integrated into the IT strategy in large companies overcoming the cultural obstacle of acquiring and physically possessing their own Data Center Machines inside their facilities being only used by the property.


text:
5. PTXdist Reference¶
5.1. Variables Reference¶
The following variables are provided by PTXdist to simplify creating rule files. Every developer should use these variables in every single line in the rule file to avoid any further adaption when external paths are changed.
To get their content related to the current project, we can simply run a:
$ ptxdist print PTXDIST_TOPDIR
Replace the
PTXDIST_TOPDIR with one of the other generic variables
PTXdist provides.
Global Variables¶
- Points always to the installation directory of PTXdist.
- Everything that references
PTXDIST_WORKSPACEwill use the active projects's folder.
PTXDIST_SYSROOT_CROSSpoints to a directory tree all cross relevant executables, libraries and header files are installed to in the current project. All of the project's packages built for the host to create data for the target are searching in this directory tree for their dependencies (executables, header and library files). Use
$(PTXDIST_SYSROOT_CROSS)/binto install executables,
$(PTXDIST_SYSROOT_CROSS)/includefor header files and
$(PTXDIST_SYSROOT_CROSS)/libfor libraries.
PTXDIST_SYSROOT_HOSTpoints to a directory tree all host relevant executables, libraries and header files are installed to. All project's packages built for the host are searching in this directory tree for their dependencies (executables, header and library files). Use
$(PTXDIST_SYSROOT_HOST)/binto install executables,
$(PTXDIST_SYSROOT_HOST)/includefor header files and
$(PTXDIST_SYSROOT_HOST)/libfor libraries.
PTXDIST_SYSROOT_TARGETpoints to a directory tree all target relevant libraries and header files are installed to. All project's packages built for the target are searching in this directory tree for their dependencies (header and library files). These files are for compile time only (for example to link a target executable against a target library), not for run-time! Use
$(PTXDIST_SYSROOT_TARGET)/includefor header files and
$(PTXDIST_SYSROOT_TARGET)/libfor libraries.
Other useful variables:
Use to find cross tools. This path must be used to create anything that depends on the target's architecture, but needs something running on the host to do the job. Examples:
- Creating a UBI image from the target's root filesystem
- This will need a tool running on the host, but it will create data or code that runs on or is used on the target
- Building a library for the target
- If this library needs other resources to be built (other libraries)
configurefinds the right information in this path.
- Used to find host tools. This path must be used to create anything that doesn't depend on the architecture.
ROOTDIRpoints to the root of the target's root filesystem in the current project. Used in very rare cases (to create strange packages based on data in target's root filesystem for example).
PTXCONF_PLATFORMexpands to the name of the currently selected platform. This name is used in various file names and paths.
PTXDIST_PLATFORMSUFFIXexpands to the name of the currently selected platform, but with a leading dot. This is used in various files PTXdist should search for.
PTXDIST_PLATFORMCONFIGDIRpoints to the directory tree of the currently selected platform. This path is used in various search functions.
PTXDIST_PLATFORMDIRpoints to the directory build tree of the currently selected platform.
PACKAGESis a list of space-separated lowercase package names that are built and installed during the PTXdist build run, and installed into the target root filesystem when building images.
-yvariant contains only those packages that are selected with
PTXCONF_<PKG>=y, while the
-mvariant contains only those which are selected with
PTXCONF_<PKG>=m(used for collections). A target package rule usually adds its name to one of those variables if it has been selected. The union of those two sets then ends up in
- In analogy to
PACKAGES, target packages that are added to these lists will be built normally during the build run. In contrast however, they are not installed into a root filesystem by default when building images, and image rules must request them explicitly. This is useful for specialized packages that are only needed for specific images, see Creating Individual Root-Filesystems for each Variant.
- Similar to
PACKAGES, these variables contain the host and cross packages that are built and installed during the PTXdist build run. There are analogous
-mvariants of those variables too.
Package Specific Variables¶
For the following variables
<PKG> is a placeholder for the package
name. It is also the Kconfig symbol name (without the
PTXCONF_ prefix).
Package Definition¶
- This is the name of the package including version. For most packages,
this is the name of the source archive (without suffix) and the source
directory. PTXdist will search for patches in a directory with this name.
This is usually defined as
<name>-$(<PKG>_VERSION). This variable is required for most packages. The only exception are packages that only install some files in the targetinstall stage (e.g. from projectroot/).
- The version of the package. It is used as the version for the ipk packages. As such, it is required for all packages that create such packages. Most target packages fall in this category.
- The md5 checksum of the source archive. PTXdist calculates the checksum before extracting the archive and will abort if does not match. Upstream project occasionally change the content of an archive without releasing a new version. This check helps to ensure that all developers work with the same source code.
- The archive suffix without the leading '.', e.g. 'tar.gz' or 'zip'. This
is only used locally to define
This is the download URL for the source archive. It is a space separated list of URLs. PTXdist will try each URL until it finds one that works. There are two main reasons to provide more than one URL: 1. Additional mirror(s) in case the main location is unavailable. 2. Some projects move old versions into a separate directory when a new version is released. Providing both versions of the URL ensures that PTXdist still has a working URL after the next upstream release.
URLs can have options. Options are appended to the URL separated by ';'. For normal downloads the following options are supported:
no-check-certificateto indicate that SSL certificate checking should be disabled.
no-proxyto disable any configured proxy.
cookie:<value>to specify a cookie that should be sent.
Files in the local filesystem can be addressed with
file://URLs. In this case, the URL can also point to a directory. In this case
<PKG>_DIRwill be a symlink to the specified directory. 'lndir://' can be used to create a shadow copy instead. For locations inside the BSP the URL should use
$(PTXDIST_WORKSPACE)to define the correct absolute path.
If no source archive is available, PTXdist can get the source from revision control systems. 'git' and 'svn' are currently supported. Note that this cannot be used to follow a branch! PTXdist will create the archive defined
<PKG>_SOURCEand use it if available.
Git URLs must either start with 'git://' or end with '.git'. They have a mandatory
Svn URLs must start with 'svn://'. They have a mandatory
The location of the downloaded source archive. There should be no reason to set this to anything other than
For local URLs (
<PKG>_SOURCEmust not be set.
The name of the patch directory, relative to any of the paths listed in
PTXDIST_PATH_PATCHES(i.e., according to the search order described in Patching Packages). If not specified, the default patch directory name is set to the value of the
This variable can be set for multiple packages that should share the same patch stack (e.g. kernel packages).
- This is the directory where the source archive is extracted. In most
cases this is set to
$(BUILDDIR)/$(<PKG>). However, if two packages use the same source archive, then something else must be used to make sure that they use different directories. See the rules for 'gdb' and 'gdbserver' for an example.
- The license of the package. The SPDX license identifiers should be used
here. Use
proprietaryfor proprietary packages and
ignorefor packages without their own license, e.g. meta packages or packages that only install files from
- A space separated list of URLs of license text files. The URLs must be
file://URLs relative to
<PKG>_DIR. Absolute URLs using
$(PTXDIST_WORKSPACE)can be used in case the license text is missing in the upstream archive. Arguments are appended with ';' as separator. The
md5=<md5sum>argument is mandatory. It defines the md5 checksum of the full license text.
startline=<number>;endline=<number>can be used in case the specified file contains more than just the license text, e.g. if the license is in the header of a source file. For non ASCII or UTF-8 files the encoding can be specified with
For most packages the variables described above are undefined by default. However, for cross and host packages these variables default to the value of the corresponding target package if it exists.
- This variable specifies a configuration file of some kind for the
packages. For packages with
<PKG>_CONF_TOOLset to
kconfigthe variable must specify an absolute path to the kconfig file. For image packages that use genimage, PTXdist will look for
config/images/$(<PKG>_CONFIG)in the BSP and PTXdist in the usual search order.
When PTXdist extracts source archives, it will create
<PKG>_DIRfirst and then extracts the archive there. If
<PKG>_STRIP_LEVELis set to 1 (the default) then PTXdist removes the first directory level defined inside the archive. For most packages that this is the same as just extracting the archive. However, this is useful for packages with badly named top-level directories or packages where the directory must be renamed to avoid collisions (e.g. gdbserver).
The main use-case for
<PKG>_STRIP_LEVELis to set it to 0 for packages without a top-level directory.
In theory
<PKG>_STRIP_LEVELcould be set to 2 or more to remove more than one directory level.
If this is set to
YESthen PTXdist will build the package out of tree. This is only supported for autoconf, qmake and cmake packages. The default is
YESfor cmake packages and
NOfor everything else. It will use
$(<PKG>_DIR)-buildas build directory.
This is especially useful for
file://URLS that point to directories to keep the source tree free of build files.
KEEPcan be used instead of
YES. In this case the build tree is not deleted at the beginning of the prepare stage. This make reconfiguration faster. This should only be used for packages that can handle configuration changes correctly and rebuild everything as needed.
- This is a directory relative to
<PKG>_DIR. If set, all build operations are executed in this directory instead. By default
<PKG>_SUBDIRis undefined so all operations are executed in the top-level directory.
Build Environment for all Stages¶
- This variable defines the PATH used by all build stages. It is evaluated
as is, so it must start with
PATH=. If undefined, PTXdist will use
PATH=$(CROSS_PATH)for target packages
PATH=$(HOST_PATH)for host packages and
PATH=$(HOST_CROSS_PATH)for cross packages. It must be set by packages that use the variable locally in the make file or if more directories are added, e.g. to
PATH=$(PTXDIST_SYSROOT_CROSS)/bin/qt5:$(CROSS_PATH)for packages that use qmake from Qt5.
- Compiler, preprocessor and linker are never called directly in PTXdist.
Instead, wrapper scripts are called that expand the command line before
calling the actual tool. These variables can be used to influence these
wrappers. The specified flags are added to the command line when
appropriate. In most cases this it the preferred way to add additional
flags. Adding them via environment variables or
makearguments can have unexpected side effects, such as as overwriting existing defaults.
- PTXdist has several options in the platformconfig that inject options in
the compiler command line. This is used, for example, to add hardening
options or change the debug options. This can occasionally cause problems
for packages that use the compiler in certain ways, such as the Linux
kernel or various bootloaders. With this variable a package can disable
individual options by setting it to a space separated list of the
corresponding Kconfig symbols (without the
Prepare Stage¶
- The environment for the prepare stage. If undefined, PTXdist will use
$(CROSS_ENV)for target packages,
$(HOST_ENV)for host packages and
$(HOST_CROSS_ENV)for cross packages. It must be set by packages that use the variable locally in the make file or if extra variables are added. In this case the definition should start with the default value.
This variable defines what tool is used to configure the package in the prepare stage. Possible values are:
NOto do nothing in the prepare stage.
autoconffor packages that use autoconf
qmakefor qmake based packages. Note: the required Qt version must be selected.
cmakefor cmake based packages. Note
HOST_CMAKEmust be selected to ensure, that cmake is available for configuration.
kconfigfor kconfig based packages. Note
<PKG>_CONFIGmust be set as described above.
perlfor perl modules.
python3for Python packages with a normal setup.py.
This variable adds arguments to the command-line of the configuration tool. If undefined, PTXdist will use a default value that depends on the configuration tool of the package. This default value should also be used when adding additional options. The following defaults exist:
- autoconf:
$(HOST_CROSS_AUTOCONF)for target/host/cross packages.
- cmake:
$(HOST_CMAKE_OPT)for target/host packages. Cross packages cannot be built with cmake
- qmake:
$(CROSS_QMAKE_OPT)for host packages. Host and cross packages cannot be built with qmake.
All other configuration tools have no default options. This variable is ignored for kconfig and python/python3.
- autoconf:
Compile Stage¶
- This variables defines additional environment variables for the compile
stage. In most cases this variable remains undefined because all
necessary defines are picked up in the prepare stage. For python/python3
packages PTXdist will use the default value from
<PKG>_CONF_ENV. For packages without configuration tool this must be set correctly, usually based on the
<PKG>_CONF_ENVdefault values, e,g.
$(CROSS_ENV)for target packages.
- This variables defines additional parameters to be forwarded to
makein order to build the package. It defaults to nothing to let
maketraditionally build the first defined target.
- This variables informs PTXdist, if this package can be built in parallel. Some
(mostly very smart selfmade) buildsystems fail doing so. In this case this
variable can be set to
NO. PTXdist will then build this package with one CPU only. The default is, to build packages in parallel.
Install Stage¶
- This variable defaults to
installwhich is used as a target for
make. It can be overwritten if the package needs a special target to install its results.
- This variable must not be set by the user. It defines package
install directory. All files will be installed relative to this
directory. It can be used by manual install stages. It is defined as
$(PKGDIR)/$(<PKG>)which expands to
<platform-dir>/packages/foo-1.1.0on our foo example.
Targetinstall Stage¶
The targetinstall stage has no additional variables.
Image Packages¶
Image packages use a different set of variables. They have the same
<PKG> and
<PKG>_DIR variables as other packages, but the rest is
- This is the filename of the image that is created by the rule. This is
- This is a list of tar balls that are extracted to generate the content of the image. PTXdist will add the necessary dependencies to these files to recreate the image as needed. If a tar ball is created by another PTXdist package then this package should be selected in the menu file.
This is another mechanism to add files to the image. It can be uses instead of or in addition to
<PKG>_FILES. It must be set to a list of ptxdist packages (the lowercase name of the packages). PTXdist will add the necessary dependencies.
Note that this will not ensure that the packages are enabled or that all all package dependencies are satisfied.
$(PTX_PACKAGES_INSTALL)can be used to specify all enabled packages. Or
$(call ptx/collection, $(PTXDIST_WORKSPACE)/configs/<collection-file-name>)can be uses to to specify the packages enabled by this collection. In both cases
=must be uses instead of
:=due to the makefile include order.
genimagepackages use this to specify the
genimageconfiguration file. PTXdist will search for the specified file name in
config/images/in the BSP, platform and PTXdist in the usual search order.
- If this is set to
YESthen PTXdist will create a special nfsroot directory that contains only the files from the packages specified in
<PKG>_PKGS. This is useful if the normal nfsroot directory contains conflicting files from multiple images. The created nfsroot directory is
- This is a tar label to put on an image. This is supported by
image-root-tgzand images created with the
5.2. Rule File Macro Reference¶
Rules files in PTXdist are using macros to get things work. Its highly recommended to use these macros instead of doing something by ourself. Using these macros is portable and such easier to maintain in the case a project should be upgraded to a more recent PTXdist version.
This chapter describes the predefined macros in PTXdist and their usage.
Whenever one of these macros installs something to the target's root filesystem,
it also accepts user and group IDs which are common in all filesystems Linux
supports. These IDs can be given as numerical values and as text strings.
In the case text strings are given PTXdist converts them into the
corresponding numerical value based on the BSP local files
passwd and
If more than one file with these names are present in the BSP PTXdist follows
its regular rules which one it prefers.
Many paths shown here contains some parts in angle brackets. These have special meanings in this document.
- <platform>
- The name of a platform. Corresponds to the variable
- <platform-src>
- The directory where the platform is defined. Corresponds to the variable
- <platform-dir>
- Concatenated directory name with a leading platform- and the name of the
selected platform name, e.g. <platform>. If the name of the currently active
platform is foo, the final directory name is platform-foo.
Corresponds to the variable
The list of supported macros is not complete yet.
$(call targetinfo)
Gives the user feedback about which build stage has just started. That's why it should always be the first call for each stage. For the package foo and the compile stage, this macro will output:
target: foo.compile
$(call touch)
Gives the user feedback about which build stage has just finished. That's why it should always be the last call for each stage. For the package foo and the compile stage, this macro will output:
finished target foo.compile
$(call clean, <directory path>)
Removes the given directory
<directory path>
world/get, world/extract, world/prepare, world/compile, world/install¶
$(call world/get, <PKG>)
The same for all other macros. These are the default build commands for the corresponding stages. For more details see the documentation of the default stages below.
$(call extract, <PKG>)
Extract a source archive into a directory.
The source archive to unpack is taken from the
<PKG>_SOURCE variable,
and the directory to unpack to is taken from the
<PKG>_DIR variable.
This macro doesn't do anything if
<PKG>_URL points to a local directory
instead of an archive or online URL.
The target directory is not removed, so
extract can be used multiple
times in a row to extract several archives. Usually clean is
called before the first
$(call compile, <PKG>, <build arguments>)
This macro is very similar to
world/compile. The only differences is
that is uses the specified
build arguments instead of
<PKG>_MAKE_OPT. This is useful if
make needs to be called more
than once in the compile stage.
world/execute, execute¶
$(call execute, <PKG>, <command with arguments>)
$(call world/execute, <PKG>, <command with arguments>)
These macros make it possible to execute arbitrary commands during the
build stages. This is useful because the environment is identical to the
default build commands
world/execute also handles the generic setup handled in the current
build stage. For
prepare this means that, for out of tree builds, the
build directory is deleted prior to executing the specified command.
install the package directory is deleted.
--verbose is used then the full command is logged. With
--quiet both stdout and stderr are redirected to the logfile.
$(call install_copy, <package>, <UID>, <GID>, <permission>, <source> [, <dest> [, <strip> ]])
Installs given file or directory into:
- the project's
- an ipkg/opkg packet in the project's
Some of the parameters have fixed meanings:
- <package>
- Name of the IPKG/OPKG the macro should work on
- User ID the file should use in the target's root filesystem
- Group ID the file should use in the target's root filesystem
- <permission>
- Permission (in an octal value) the file should use in the target's root filesystem
The remaining parameters vary with the use case:
<source> parameter can be:
- a directory path that should be created in the target's root filesystem.
In this case the <destination> must be omitted.
The given path must always start with a
/and means the root of the target's filesystem.
- an absolute path to a file that should be copied to the target's root
filesystem. To avoid fixed paths, all packages are providing the
<PKG>_DIR variable. So, this parameter in our
foo example package can be a
- a minus sign (
-). PTXdist uses the <destination> parameter in this case to locate the file to copy from. The <destination> is uses a path relative to the package install directory. This only works if the package uses the default or a similar install stage. For our foo example used source file is
<dest> parameter can be:
- omitted if a directory in target's root filesystem should be created. For this case the directory to be created is in the <source> parameter.
- an absolute path and filename with its root in target's root filesystem.
It must start with a slash (
//). If also the <source> parameter was given, the file can be renamed while copying. If the <source> parameter was given as a minus sign (
-) the <destination> is also used to locate the source. For our foo example package if we give <destination> as
/usr/bin/foo, PTXdist copies the file
<strip> is a complete optional parameter to prevent
this macro from the regular stripping process it does on files. Most of the cases
stripping debug information from files is intended. But some kind of files getting
destroyed when this stripping happens to them. One example is a Linux kernel module.
If it gets stripped, it can't be loaded into the kernel anymore.
- full strip
- fully strip the file while installing when this parameter is y or not given at all (default case).
- partially strip
- only strips real debug information from the file when this parameter is k. Useful to keep Linux kernel module loadable at run-time
- no strip
- preserve the file from being stripped when this parameter is one of the following: 0, n, no, N or NO.
Due to the complexity of this macro, here are some usage examples:
Create a directory in the root filesystem:
$(call install_copy, foo, 0, 0, 0755, /home/user-foo)
Copy a file from the package build directory to the root filesystem:
$(call install_copy, foo, 0, 0, 0755, $(FOO_DIR)/foo, /usr/bin/foo)
Copy a file from the package build directory to the root filesystem and rename it:
$(call install_copy, foo, 0, 0, 0755, $(FOO_DIR)/foo, /usr/bin/bar)
Copy a file from the package install directory to the root filesystem:
$(call install_copy, foo, 0, 0, 0755, -, /usr/bin/foo)
$(call install_tree, <package>, <UID>, <GID>, <source dir>, <destination dir>, <strip>])
Installs the whole directory tree with all files from the given directory into:
- the project's
- an ipkg packet in the project's
Some of the parameters have fixed meanings:
- <package>
- Name of the IPKG/OPKG the macro should work on
- User ID the directories and files should use in the target's root filesystem
-to keep the UID from the source tree
- Group ID the directories and files should use in the target's root filesystem
-to keep the GID from the source tree
- <source dir>
- This is the path to the tree of directories and files to be installed. It can
-to use the package directory of the current package instead
- <destination dir>
- The basename of the to-be-installed tree in the root filesystem
- <strip>
- same as for install_copy.
Note: This installation macro
- uses the same permission flags in the destination dir as found in the source dir. This is valid for directories and regular files
- skips all directories with names like
CVSin the source directory
Install the whole tree found in
/home/jbe/foo to the root filesystem
at location
$(call install_tree, foo, 0, 0, /home/jbe/foo, /usr/share/bar)
Install all files from the tree found in the current package FOO to the root
filesystem at location
$(call install_tree, foo, 0, 0, -, /usr/share/bar)
If the current package is
foo-1.0 the base path for the directory tree
will be
$(call install_alternative_tree, <package>, <UID>, <GID>, <destination dir>)
Installs the whole source directory tree with all files from the given directory into:
- the project's
- an ipkg packet in the project's
<destination dir> is used like in the
install_alternative to let
PTXdist search in the same directories and order for the given directory.
Some of the parameters have fixed meanings:
- <package>
- Name of the IPKG/OPKG the macro should work on
- User ID the directories and files should use in the target's root filesystem
-to keep the UID from the source
- Group ID the directories and files should use in the target's root
filesystem or
-to keep the GID from the source
- <destination dir>
- The basename of the to-be-installed tree in the root filesystem
This installation macro
- uses the same permission flags in the destination dir as found in the source dir. This is valid for directories and regular files
- skips all directories with names like
CVSin the source directory
Install the whole tree found in project's
to the root filesystem at location
$(call install_alternative_tree, foo, 0, 0, /usr/share/bar)
To install nothing, use a symlink to
/dev/null instead of the base
directory. See install_alternative for more details.
$(call install_alternative, <package>, <UID>, <GID>, <permission>, <destination>)
Installs given files or directories into:
- the project's
- an ipkg/opkg packet in the project's
The base parameters and their meanings:
- <package>
- Name of the IPKG/OPKG the macro should work on
- User ID the file should use in the target's root filesystem
- Group ID the file should use in the target's root filesystem
- <permission>
- Permission (in an octal value) the file should use in the target's root filesystem
The parameter <destination> is meant as an absolute path and filename in target's root filesystem. PTXdist searches for the source of this file in:
- the local project
- in the used platform
- PTXdist's install path
- in the current package
As this search algorithm is complex, here an example for the file
/etc/foo in package
FOO. PTXdist will search for this
file in the following order:
- project's directory
- project's directory
- platform's directory
- project's directory
- platform's directory
- ptxdist's directory
- package's directory
- package's directory
The generic rules are looking like the following:
Note: You can get the current values for the listed variables above via running
PTXdist with the
$ ptxdist print PTXDIST_PLATFORMSUFFIX
install_alternative is used by upstream PTXdist packages to install
config files. In some rare use-cases the file should not be installed at
all. For example if the config file is generated at runtime or provided by
a special configuration package. This is possible by creating a symlink to
/dev/null instead of a file at one of the locations described above.
PTXdist skips installing the file if it detects such a symlink.
$(call install_link, <package>, <point to>, <where>)
Installs a symbolic link into:
- the project's
- an ipkg/opkg packet in the project's
The parameters and their meanings:
- <package>
- Name of the IPKG/OPKG the macro should work on
- <point to>
- Path and name the link should point to. Note: This macro rejects absolute paths. If needed use relative paths instead.
- <where>
- Path and name of the symbolic link.
A few usage examples.
Create a symbolic link as
/usr/lib/libfoo.so pointing to
libfoo.so.1.1.0 in the same directory:
$(call install_link, foo, libfoo.so.1.1.0, /usr/lib/libfoo.so)
Create a symbolic link as
/usr/bin/foo pointing to
$(call install_link, foo, ../../bin/bar, /usr/bin/foo)
$(call install_archive, <package>, <UID>, <GID>, <archive> , <base path>)
Installs archives content into:
- the project's
- an ipkg/opkg packet in the project's
All parameters have fixed meanings:
- <package>
- Name of the IPKG/OPKG the macro should work on
- User ID all files and directory of the archive should use in the target's
root filesystem. A
-uses the file's/directory's UID in the archive
- Group ID the files and directories should use in the target's root filesystem.
-uses the file's/directory's GID in the archive
- <archive>
- Name of the archive to be used in this call. The given path and filename is used as is
- <base path>
- Base path component in the root filesystem the archive should be extracted
to. Can be just
/for root.
$(call install_glob, <package>, <UID>, <GID>, <source dir>, <destination dir>, <yglob>, <nglob>[, <strip>])
Installs parts of a directory tree with all files from the given directory into:
- the project's
- an ipkg packet in the project's
Some of the parameters have fixed meanings:
- <package>
- Name of the IPKG/OPKG the macro should work on
- User ID the directories and files should use in the target's root filesystem
-to keep the UID from the source tree
- Group ID the directories and files should use in the target's root filesystem
-to keep the GID from the source tree
- <source dir>
- This is the path to the tree of directories and files to be installed. It can
-to use the package directory of the current package instead
- <destination dir>
- The basename of the to-be-installed tree in the root filesystem
- <yglob>
- A list of pathname patterns. All files or directories that match _any_
pattern in the list are installed. Note: the patterns must match the
whole absolute path, e.g.
*/foo. An empty list is equivalent to a pattern that matches all files.
- <nglob>
- Like
<yglob>but any matching files or directories will not be installed. For directories, this includes the whole contents of the directory.
Except for the pathname patterns, this command works like
<yglob> and
<nglob> patterns are combined: Only files that
<yglob> and do not match
<nglob> are installed.
Install all shared libraries found in
$(FOO_PKGDIR)/usr/lib/foo except
$(call install_glob, foo, 0, 0, -, /usr/lib/foo, *.so, */libbar.so)
$(call install_lib, <package>, <UID>, <GID>, <permission>, <libname>)
Installs the shared library <libname> into the root filesystem.
- the project's
- an ipkg/opkg packet in the project's
The parameters and their meanings:
- <package>
- Name of the IPKG/OPKG the macro should work on
- User ID the file should use in the target's root filesystem
- Group ID the directories and files should use in the target's root filesystem
- <permission>
- Permission (as an octal value) the library should use in the target's root filesystem (mostly 0644)
- <libname>
- Basename of the library without any extension and path
install_lib macro searches for the library at the most
common directories
/lib and
/usr/lib. And it searches always
in the package's corresponding directory in
It also handles all required links to make the library work at run-time.
An example.
Lets assume the package 'foo-1.0.0' has installed the library
libfoo into
<platform-dir>/packages/foo-1.0.0 at:
- the lib:
- first link:
- second link:
The second link is only needed for the linker at build-time to
-lfoo1. It is not needed at run-time so
install_lib will
skip it.
To install this library and its corresponding link, the following line does the job:
$(call install_lib, foo, 0, 0, 0644, libfoo1)
Note: The package's install stage must be 'DESTDIR' aware to be able to make
it install its content into the corresponding packages directory (in our example
<platform-dir>/packages/foo-1.0.0/ here).
$(call install_replace, <package>, <filename>, <placeholder>, <value>)
Replace placeholder with value in a previously installed file.
The parameters and their meanings:
- <package>
- Name of the IPKG/OPKG the macro should work on
- <filename>
- Absolute filepath in target root filesystem
- <placeholder>
- A string in the file which should be replaced. Usually some uppercase word surrounded by @ signs
- <value>
- The value which should appear in the root filesystem instead of the placeholder, could be some PTXCONF variable
install_replace macro can be used in targetinstall stage to adapt
some template and replace strings with content from menu variables or other
sources. For example look at the timezone you set in the ptxdist menu. An
install_replace call in
rules/timezone.make replaces the string
@TIMEZONE@ in the file
/etc/timezone in root filesystem with the
content of the menu variable
PTXCONF_TIMEZONE_LOCALTIME. The file must
be installed with some other
install_* command before
install_replace can be used. A typical call would look like this:
@$(call install_replace, timezone, /etc/timezone, @TIMEZONE@, \
ptx/endis, ptx/disen, ptx/wow, ptx/wwo, ptx/yesno, ptx/truefalse, ptx/falsetrue, ptx/onoff, ptx/ifdef¶
$(call ptx/endis, VARIABLE)
$(call ptx/disen, VARIABLE)
$(call ptx/wow, VARIABLE)
$(call ptx/wwo, VARIABLE)
$(call ptx/yesno, VARIABLE)
$(call ptx/truefalse, VARIABLE)
$(call ptx/falsetrue, VARIABLE)
$(call ptx/onoff, VARIABLE)
$(call ptx/ifdef, VARIABLE, [expansion-if-true], [expansion-if-false])
Several macros exist to convert the state (set/unset) of a variable into a string.
These are useful for
<PKG>_CONF_OPT variables, and expand as follows:
|Macro name
|Expansion if
VARIABLE set
|Expansion if
VARIABLE unset
|Exemplary use case
|autoconf cache vars
|the second parameter
|the third parameter
Some real-life examples:
1 2 3 4 5 6 7 8 9 10 11
BASH_CONF_OPT += --$(call ptx/endis, PTXCONF_BASH_DEBUGGER)-debugger
OPENOCD_CONF_OPT += --$(call ptx/disen, PTXCONF_OPENOCD_PARPORT_DISABLE_PARPORT_PPDEV)-parport-ppdev
COREUTILS_CONF_OPT += --$(call ptx/wwo, PTXCONF_GLOBAL_SELINUX)-selinux
LESS_CONF_ENV += ac_cv_lib_ncurses_initscr=$(call ptx/yesno, PTXCONF_LESS_NCURSES)
SYSTEMD_CONF_OPT += -Dmicrohttpd=$(call ptx/truefalse,PTXCONF_SYSTEMD_MICROHTTPD)
SYSTEMD_CONF_OPT += -Drandomseed=$(call ptx/falsetrue,PTXCONF_SYSTEMD_DISABLE_RANDOM_SEED)
MYSQL_CONF_OPT += -DWITH_SYSTEMD=$(call ptx/onoff, PTXCONF_MYSQL_SYSTEMD)
CUPS_CONF_OPT += $(call ptx/ifdef,PTXCONF_CUPS_PERL,--with-perl=/usr/bin/perl,--without-perl)
If the respective variable is set, these statements would expand to:
1 2 3 4 5 6 7 8 9 10 11
BASH_CONF_OPT += --enable-debugger
OPENOCD_CONF_OPT += --disable-parport-ppdev
COREUTILS_CONF_OPT += --with-selinux
LESS_CONF_ENV += ac_cv_lib_ncurses_initscr=yes
SYSTEMD_CONF_OPT += -Dmicrohttpd=true
SYSTEMD_CONF_OPT += -Drandomseed=false
MYSQL_CONF_OPT += -DWITH_SYSTEMD=on
CUPS_CONF_OPT += --with-perl=/usr/bin/perl
whereas if the respective variable is unset, they would expand to the opposite:
1 2 3 4 5 6 7 8 9 10 11
BASH_CONF_OPT += --disable-debugger
OPENOCD_CONF_OPT += --enable-parport-ppdev
COREUTILS_CONF_OPT += --without-selinux
LESS_CONF_ENV += ac_cv_lib_ncurses_initscr=no
SYSTEMD_CONF_OPT += -Dmicrohttpd=false
SYSTEMD_CONF_OPT += -Drandomseed=true
MYSQL_CONF_OPT += -DWITH_SYSTEMD=off
CUPS_CONF_OPT += --without-perl
This macro can be used to find files or directories in the BSP and PTXdist. There are two arguments, prefix and file. The search path is very similar to install_alternative. The first existing location of the following paths is returned:
This macro can be used to find files or directories in the BSP and PTXdist.
There are two arguments, path variable and file. The path
variable must be a variable name that is available in a shell called by
make. The variable must contain a
: separated list of directories.
The file will be searched in these directories and the first existing
path is returned. PTXdist defines several variables that can be used here.
The directories are in the usual search order.
- PTXDIST_PATH_LAYERS contains all layers from PTXDIST_WORKSPACE to PTXDIST_TOPDIR
- PTXDIST_PATH is like PTXDIST_PATH_LAYERS but also contains the PTXDIST_PLATFORMCONFIGDIR for each layer.
- PTXDIST_PATH_SCRIPTS, PTXDIST_PATH_RULES and
PTXDIST_PATH_PLATFORMS are like PTXDIST_PATH with the extra
platforms/subdirectory respectively.
Hint: use the print command to get the exact list of directories for each of these variables.
This macro is only useful with multiple layers. It has one argument
file. The file is searched for in the platform directory in
all layers in the usual search order. It returns the first existing file.
If none exists it returns
$(PTXDIST_PLATFORMCONFIGDIR)/$(file). This
avoids unexpected errors due to empty variables if a file is missing.
5.3. Rule File Layout¶
Each rule file provides PTXdist with the required steps (in PTXdist called stages) to be done on a per package base:
- get
- extract
- extract.post
- prepare
- compile
- install
- install.pack
- install.unpack
- install.post
- targetinstall
- targetinstall.post
Host, image and cross packages don't need to install anything in the target file system.
Therefore, PTXdist only respects the targetinstall and targetinstall.post
stages for packages whose name doesn't start with
image-, or
When you want to depend on the output of a certain image package, you can usually use its image name as an additional prerequisite in your make rule for the dependent stage.
Default stage rules¶
As for most packages these steps can be done in a default way, PTXdist provides generic rules for each package. If a package's rule file does not provide a specific stage rule, the default stage rule will be used instead.
Omitting one of the stage rules does not mean that PTXdist skips this stage! In this case the default stage rule is used instead.
get Stage Default Rule¶
If the get stage is omitted, PTXdist runs instead:
@$(call targetinfo)
@$(call touch)
Which means this step is skipped.
If the package is an archive that must be downloaded from the web, the following rule must exist in this case:
@$(call targetinfo)
@$(call get, <PKG>)
extract Stage Default Rule¶
If the extract stage is omitted, PTXdist runs instead:
@$(call targetinfo)
@$(call clean, $(<PKG>_DIR))
@$(call extract, <PKG>)
@$(call patchin, <PKG>)
@$(call touch)
Which means a current existing directory of this package will be removed, the archive gets freshly extracted again and (if corresponding patches are found) patched.
extract.post Stage Default Rule¶
This is an optional stage, mainly used to somehow prepare a package for the
next prepare stage step. This stage can be used to generate a
script out of an autotoolized
configure.ac file for example. This separation
from the extract stage is useful to be able to extract a package for a quick
look into the sources without the need to build all the autotools first. The
autotoolized PTXdist templates makes use of this feature. Refer
Creating Autotools based Packages for further details.
prepare Stage Default Rule¶
If the prepare stage is omitted, PTXdist runs a default stage rule, which looks like this:
@$(call targetinfo)
@$(call world/prepare, <PKG>)
@$(call touch)
world/prepare does depends on some variable settings.
If the package's rule file defines
<PKG>_CONF_TOOL to
this stage is simply does nothing.
All rules files can create the
<PKG>_CONF_ENV variable and should
define it at least to
$(CROSS_ENV) (the default) if the prepare stage
is used.
If the package's rule file defines
<PKG>_CONF_TOOL to
autoconf (
FOO_CONF_TOOL = autoconf for our foo example),
PTXdist treats this package as an autotoolized package and
world/prepare expands to something like this:
cd ${<PKG>_DIR}/${<PKG>_SUBDIR} && \
./configure ${<PKG>_CONF_OPT}
<PKG>_CONF_OPT should at least be defined to
If the package's rule file defines
<PKG>_CONF_TOOL to
FOO_CONF_TOOL = cmake for our foo example), PTXdist treats this
package as a cmake based package and
world/prepare expands to
something like this:
cd ${<PKG>_DIR} && \
cmake ${<PKG>_CONF_OPT}
<PKG>_CONF_OPT should at least be defined to
$(CROSS_CMAKE_USR) or
If the package's rule file defines
<PKG>_CONF_TOOL to
FOO_CONF_TOOL = qmake for our foo example), PTXdist treats this
package as a qmake based package and
world/prepare expands to
something like this:
cd ${<PKG>_DIR} && \
qmake ${<PKG>_CONF_OPT}
<PKG>_CONF_OPT should at least be defined to
compile Stage Default Rule¶
If the compile stage is omitted, PTXdist runs instead:
@$(call targetinfo)
@$(call world/compile, <PKG>)
@$(call touch)
Except in some corner cases,
world/compile expands to something like
cd ${<PKG>_DIR} && \
The variables that are used here are described in the Compile Stage section of the variable reference.
PARALLELMFLAGS can be used in custom compile stages. The default stage
uses the same value if
<PKG>_MAKE_PAR is set to
install Stage Default Rule¶
If the install stage is omitted, PTXdist runs instead:
@$(call targetinfo)
@$(call world/install, <PKG>)
@$(call touch)
Except in some corner cases,
world/install expands to something like
cd ${<PKG>_DIR} && \
The variables that are used here are described in the Install Stage section of the variable reference.
At the end of this stage, all relevant files must be installed in the package install directory.
install.pack Stage Default Rule¶
The install.pack should not be overwritten. It consists of two steps. The first is, to make the installed files relocatable. This is necessary to ensure that everything works correctly once the files are copied to sysroot in install.post. If creating pre-built archives is enabled, then the second step is to create the archive for the package.
install.unpack Stage Default Rule¶
The install.unpack is only executed if using pre-built archives is enabled. In this case, it replaces all previous stages. Here, the pre-built is extract.
install.post Stage Default Rule¶
The install.post is mostly internal. Few packages need to customize it. It copies all files from the package install directory into the corresponding sysroot.
targetinstall Stage Default Rule¶
There is no default rule for a package's targetinstall state. PTXdist has no idea what is required on the target at run-time. This stage is up to the developer only. Refer to section Rule File Macro Reference for further info on how to select files to be included in the target's root filesystem.
targetinstall.post Stage Default Rule¶
The targetinstall.post stage does nothing by default. It can be used to do some work after the targetinstall stage.
Skipping a Stage¶
For the case that a specific stage should be really skipped, an empty rule must be provided:
@$(call targetinfo)
@$(call touch)
Replace the <stage_to_skip> by
install or
5.4. PTXdist parameter reference¶
PTXdist is a command line tool, which is basically called as:
$ ptxdist <action [args]> [options]
Setup and Project Actions¶
- this starts a dialog based frontend for those who do not like typing commands. It will gain us access to the most common parameters to configure and build a PTXdist project. This menu handles the actions menuconfig, platformconfig, kernelconfig, select, platform, boardsetup, setup, go and images.
select <config>
- this action will select a user land
configuration. This step is only required in projects where no
selected_ptxconfigfile is present. The <config> argument must point to a valid userland configuration file. PTXdist provides this feature to enable the user to maintain more than one userland configuration in the same project. The default location for the configuration file is
configs/ptxconfig. PTXdist will use this if no other configuration is selected.
platform <config>
- this action will select a platform
configuration. This step is only required in projects where no
selected_platformfile is present. The <config> argument must point to a valid platform configuration file. PTXdist provides this feature to enable the user to maintain more than one platform in one project. The default location for the configuration file is
configs/*/platformconfig. PTXdist will use that if the pattern matches exactly one file and no other configuration is selected.
toolchain [<path>]
- this action will select the toolchain to use. If no path is specified then PTXdist will guess which toolchain to use based on the settings in the platformconfig. Setting the toolchain is only required if PTXdist cannot find the toolchain automatically or if a different toolchain should be used.
collection <config>
- this action will select a collection configuration. This step is optional. The <config> argument must point to a valid collection configuration file.
- PTXdist uses some global settings, independent from the project it is working on. These settings belong to users preferences or simply some network settings to permit PTXdist to download required packages.
- PTXdist based projects can provide information to setup and configure the target automatically. This action lets the user setup the environment specific settings like the network IP address and so on.
- start the menu to configure the project's root filesystem. This is in respect to userland only. It's the main menu to select which applications and libraries should be built into the target's root filesystem.
menuconfig platform
- this action starts the menu to configure the currently selected
platform. As these are architecture and target specific
settings, it configures the toolchain, the kernel and a bootloader (but
no userland components).
The short form for this action is
menuconfig kernel
- start the menu to configure the platform's
kernel. As a project can support more than one platform, this will
configure the currently selected platform. The short form for this
action is
menuconfig barebox
- this action starts the configure menu for
the selected bootloader. It depends on the platform settings which
bootloader is enabled and to be used as an argument to the
menuconfigaction parameter. As a project can support more than one platform, this will configure the bootloader of the currently selected platform.
nconfig [<component>]
- this action provides a slightly different user experience with the same
functionality as
menuconfig. It can be used instead of
menuconfigfor all the component described above.
oldconfig [<component>],
allmodconfig [<component>],
allyesconfig [<component>],
allnoconfig [<component>],
randconfig [<component>]
- this action will run the corresponding kconfig action for the specified
oldconfigwill prompt for all new options.
allnoconfigwill set all options to 'm', 'y' or 'n' respectively.
randconfigwill randomize the options. The
KCONFIG_SEEDenvironment variables can be used as described in the Linux kernel documentation.
- migrate the configuration files from a previous PTXdist version. This
will run
oldconfig platformto prompt for all new options.
Build Actions¶
- this action will build all enabled packages in the current project configurations (platform and userland). It will also rebuild reconfigured packages (if any) or build additional packages if they were enabled meanwhile. If enabled, this step also builds the kernel and bootloader images.
- this action will download the sources for all packages. This is useful to download everything at once. Afterwards the packages can be built without internet access.
- if using pre-built archives is enabled, this action will make sure that all of them exist locally, possibly by downloading them from the configured mirror server.
urlcheck [<package>]
- this action will check if the URL for the package (or all packages) still works. It does not download the whole file, so this is relatively fast, but may not be 100% correct in all cases.
get <package>,
extract <package>,
prepare <package>,
compile <package>,
install <package>,
targetinstall <package>
- these actions will build the corresponding stage for the specified package including all previous stages and other dependencies. Multiple packages can be specified.
drop <package>.<stage>
- this action will 'drop' the specified stage without removing any other
files. Subsequent actions depending on this stage will rebuild it.
This is useful during
development to rebuild a package without deleting the sources. Use
clean <package>for a full rebuild of the package.
most of the time this is the last step to get the required files and/or images for the target. It creates filesystems or device images to be used in conjunction with the target's filesystem media. The result can be found in the
images/directory of the project or the platform directory.
If necessary,
imagesalso builds all required stages first, so it can be used instead of
image <image>
- build the specified image. The file name in
images/is used to identify the image. This is basically the same as
imagesbut builds just one image.
Clean Actions¶
- the
cleanaction will remove all generated files: all build, packages and root filesystem directories. Only the selected configuration files are left untouched. This is a way to start a fresh build cycle.
clean root
- this action will only clean the image packages and the root filesystem
directories. All the build directories are left untouched.
After using this action, the next
goaction will regenerate all opkg archives from the already built packages as well as the root filesystem directories. The
clean rootand
goaction is useful if the targetinstall stage for all packages should run again.
clean target
- this action will call the
cleanaction for each target package, and also clean the root file system afterwards. This can be useful if you want to rebuild the target file system from scratch, without throwing away the already built host and cross packages.
clean <package>
- this action will only clean the dedicated <package>. It will remove its build directory and all installed files from the corresponding sysroot directory. Multiple packages can be specified.
- the
distcleanaction will remove all files that are not part of the main project. It removes all generated files and directories like the
cleanaction, and also the created links in any
Misc Actions¶
- print out the PTXdist version.
test <testname>
- run tests
newpackage <type>
- create a new PTXdist package. For most package types, this will create
<pkg>.make and <pkg>.in files in
rules/. Use
newpackage helpfor a list of available package types.
- run a userspace NFS server and export the nfsroot (refer to section Using a userland NFS Server for the Target for further details).
- run the cross gdb from the toolchain. The sysroot and other search paths are configured to ensure that gdb finds all available debug files.
- show some basic information about the BSP. The currently used configs, all layers, the images that are build, etc.
package-info <pkg>
- show some basic information about the package. This includes the version, URL and various paths and directories. The paths for menu and rule file are shown as well, so this can be used to verify that the correct version of these files are used.
print <var>
- print the contents of a variable. It will first look for a shell variable with the given name. If none exists, it will run make on all selected package rules, determine if a variable with the given name is known to make, and if so, print it. For make variables, <var> can contain '%'. In this case, all variables that match the pattern are printed. If the <var> is undefined, then an error will be generated unless '-k' is used. In that case an empty value is returned.
printnext <var>
- assume that the contents of <var> is another variable and print the
contents of this variable. Shell variables are currently not checked here.
All other rules for
- print a list of all selected packages. This list does not include the host and cross tools.
local-src <pkg> [<directory>]
- overwrite a package source with a locally provided directory containing the source code. Not specifying the directory will undo the change. Relative paths are converted to absolute paths relative to the workspace.
- enter a PTXdist environment bash shell.
bash <cmd> [args...]
- execute
<cmd>in PTXdist environment.
make <target>
- build specified make target in PTXdist.
export_src <target-dir>
- export all source archives needed for this project to
- build HTML documentation for a BSP. The output is written to Documentation/html/index.html
Overwrite defaults¶
These options can be used to overwrite default settings. They can be useful when working with multiple configurations or platforms in a single project.
- use the specified ptxconfig file instead of the selected default configuration file.
- use specified platformconfig file instead of the selected default configuration file.
- use specified collectionconfig file instead of the selected configuration file.
- use specified toolchain instead of the selected or default toolchain.
- allow downloading, even if disabled by
- use this option to overwrite various sanity checks. Only use this option if you really know what you are doing!
- print out additional info (like make decisions)
- suppress output, show only stderr
- be more verbose, print command before execute them
enable or disable output synchronization. By default output synchronization is only enabled for quiet builds. Output synchronization is implemented by the
--output-syncoption. For building packages in parallel,
--output-sync=recurseis used. For individual
makecommands in the build stages
--output-sync=targetis used. This means that the output for each individual make target and each build stage is grouped together.
Note: If output synchronization is enabled, then the output for each build stage is collected by make and won't be visible until the build stage is completed. As a result, there will be long periods of time with no visible progress.
- show some progress information in the form of completed/total build
stages. This is only shown if
--quietis enabled as well. Note that this adds some extra overhead at the beginning, so it will take some time until the first build stage starts.
- set number of parallel jobs within packages. PTXdist will use this
number for example when calling
makeduring the compile stage. The default is 2x the number of CPUs.
- set number of packages to be built in parallel. The default is 1.
-jinstead of this. It has the same goal and performs better.
set the global number of parallel jobs. This is basically a more intelligent combination of
-ji. A single package rarely uses all the available CPUs. Usually only the compile stage can use more than one CPU and even then there are often idle CPUs. With the global job pool, tasks from multiple packages can be executed in parallel without overloading the system.
Note: Because of the parallel execution, the output is chaotic and not very useful. Use this in combination with
-qand only to speed up building for projects that are known to build without errors.
- try to limit load to <n>. This is used for the equivalent
- run with reduced scheduling priority (i.e. nice). The default is 10.
avoid rebuilding packages. By default, if a package is rebuilt, then all packages that depend on it are also rebuilt. This happens because PTXdist cannot know if rebuilding is functionally necessary for the depending packages. By specifying
--dirty, depending packages will not be rebuilt if their dependencies were rebuilt. Also, changes to config options, rule and menu file or changed patches will not trigger a rebuild either.
To trigger a rebuild, the relevant stage of a package must be dropped.
- keep going. Continue to build as much as possible after an error.
- use git to apply patches
- automatically switch to the correct PTXdist version. This will look for the correct PTXdist version in the ptxconfig file and execute it if it does not match the current version.
- include a Python Virtual Environment. The given path must contain a
bin/activateshell script.


text:
Items Tagged: Composable
Agile Big Data Clusters: DriveScale Enables Bare Metal Cloud
We've been writing recently about the hot, potentially inevitable, trend, towards a dense IT infrastructure in which components like CPU cores and disks are not only commoditized, but deployed in massive stacks or pools (with fast matrixing switches between them). Then a layered provisioning solution can dynamically compose any desired "physical" server or cluster out of those components. Conceptually this becomes the foundation for a bare-metal cloud. DriveScale today announces their agile architecture with this approach, aimed first at solving big data multi-cluster operational challenges.
- Premiered: 05/19/16
- Author: Mike Matchett
HPE gives software-defined storage a new twist with the StoreVirtual 3200
The recent trend for software-defined storage vendors has been to create hyperconverged platforms in order to continue to add greater functionality to the same X86-based servers they rely on.
- Premiered: 08/17/16
- Author: Jeff Kato
HPE 3PAR Enables Highly Resilient All-Flash Data Centers: Latest Release Solidifies AFA Leadership
If you are an existing customer of HPE 3PAR, this latest release of 3PAR capabilities will leave you smiling. If you are looking for an All Flash Array (AFA) to transform your data center, now might be the time to take a closer at HPE 3PAR. Since AFAs first emerged on the scene at the turn of this decade, the products have gone through various waves of innovation to achieve the market acceptance it has today. In the first wave, it was all about raw performance for niche applications. In the second wave, it was about making flash more cost effective versus traditional disk-based arrays to broaden economic appeal. Now in the final wave, it is about giving these arrays all the enterprise features and ecosystem support to completely replace all legacy Tier 0/1 arrays still in production today.
HPE 3PAR StoreServ is one of the leading AFAs on the market today. HPE 3PAR uses a modern architectural design that includes multi-controller scalability, a highly-virtualized data layer with three levels of abstraction, system-wide striping, a highly-specialized ASIC and numerous flash innovations. HPE 3PAR engineers pioneered this very efficient architecture well before flash technology became mainstream and proved that this architecture approach has been timeless by demonstrating a seamless transition to support all-flash technology. During this same time, other vendors ran into architectural controller-bound bottlenecks for flash, making them reinvent existing products or completely start from scratch with new architectures.
HPE's 3PAR timeless architecture has meant that features introduced years before are still relevant today and features introduced today are available to current 3PAR customers that purchased arrays previously. This continuous innovation of features available to old and new customers alike provides the ultimate in investment protection unmatched by most vendors in the industry today. In this Technology Brief, Taneja Group will explore some of the latest developments from HPE that build upon the rich feature set that already exists in the 3PAR architecture. These new features and simplicity enhancements will show that HPE continues to put customer's investment protection first and continues to expand its capabilities around enterprise-grade business continuity and resilience. The combination of economic value of HPE 3PAR AFAs with years of proven mission critical features promises to accelerate the final wave of the much-anticipated All-Flash Data Center for Tier 0/1 workloads.
HPE StoreVirtual 3200: A Look at the Only Entry Array with Scale-out and Scale-up
Innovation in traditional external storage has recently taken a back seat to the current market darlings of All Flash Arrays and Software-defined Scale-out Storage. Can there be a better way to redesign the mainstream dual-controller array that has been a popular choice for entry-level shared storage for the last 20 years? Hewlett-Packard Enterprise (HPE) claims the answer is a resounding Yes.
HPE StoreVirtual 3200 (SV3200) is a new entry storage device that leverages HPE's StoreVirtual Software-defined Storage (SDS) technology combined with an innovative use of low-cost ARM-based controller technology found in high-end smartphones and tablets. This approach allows HPE to leverage StoreVirtual technology to create an entry array that is more cost effective than using the same software on a set of commodity X86 servers. Optimizing the cost/performance ratio using ARM technology instead of excessive power hungry processing and memory using X86 computers unleashes an attractive SDS product unmatched in affordability. For the first time, an entry storage device can both Scale-up and Scale-out efficiently and also have the additional flexibility to be compatible with a full complement of hyper-converged and composable infrastructure (based on the same StoreVirtual technology). This unique capability gives businesses the ultimate flexibility and investment protection as they transition to a modern infrastructure based on software-defined technologies. The SV3200 is ideal for SMB on-premises storage and enterprise remote office deployments. In the future, it will also enable low-cost capacity expansion for HPE's Hyper Converged and Composable infrastructure offerings.
Taneja Group evaluated the HPE SV3200 to validate the fit as an entry storage device. Ease-of-use, advanced data services, and supportability were just some of the key attributes we validated with hands-on testing. What we found was that the SV3200 is an extremely easy-to-use device that can be managed by IT generalists. This simplicity is good news for both new customers that cannot afford dedicated administrators and also for those HPE customers that are already accustomed to managing multiple HPE products that adhere to the same HPE OneView infrastructure management paradigm. We also validated that the advanced data services of this entry array match that of the field proven enterprise StoreVirtual products already in the market. The SV3200 can support advanced features such as linear scale-out and multi-site stretch cluster capability that enables advanced business continuity techniques rarely found in storage products of this class. What we found is that HPE has raised the bar for entry arrays, and we strongly recommend businesses that are looking at either SDS technology or entry storage strongly consider HPE's SV3200 as a product that has the flexibility to provide the best of both. A starting price at under $10,000 makes it very affordable to start using this easy, powerful, and flexible array. Give it a closer look.
Disaggregating network, compute and storage allocation demystified
Explore the ways disaggregation concepts and principles are being applied to create and allocate pools of compute and storage resources to serve applications on demand.
- Premiered: 08/02/17
- Author: Arun Taneja
- Published: Storage Magazine
What's a Multi-cloud Really? Some Insider Notes from VMworld 2017
As comfortable 65-70 degree weather blankets New England here as we near end of summer, flying into Las Vegas for VMworld at 110 degrees seemed like dropping into hell.... as everyone still able to breathe immediately says -"at least it's a dry heat."... Anyway, VMworld inside was much nicer - ... For us analysts, VMworld is work after all! We had a great set of meetings with a number of our past (and hopefully future) clients at the show, and got some great inside scoop on VMware plans during their analyst sessions. Past the top line news and keynote announcements, here are a few deeper notes of interest.,,,
- Premiered: 09/07/17
- Author: Mike Matchett
Cloud-based environment: The new normal for IT shops
The sky is the limit as new cloud management tools and evolutions in storage help make hybrid and multicloud IT a viable option for organizations with on-prem data centers.
- Premiered: 10/19/17
- Author: Mike Matchett
- Published: TechTarget: Search Server Virtualization
Composable infrastructure creates new path to SDDC nirvana
Shiny new products like composable infrastructure and on-premises cloud platforms could offer a way to achieve software-defined infrastructure - but beware the pitfalls.
- Premiered: 11/16/17
- Author: Taneja Group
- Published: TechTarget: Search Data Center


text:
Let me guess, you have been playing New York Times crossword and got stuck on the clue Repairman. Well, you have come to the right place to find the answer to this clue.
While some crosswords are much simpler than others, most require that players have a vast knowledge of the language and possibly even various topics. So while crossword puzzles are seen as a more intelligent game, they can be very frustrating for players to complete and even experienced crossword players need some help occasionally.
When finding the answers to the clues becomes too difficult, there's no shame in looking for them online.
Now you have the answer to your clue. Its time to move on to the next clue. You can browse through the list with all the answers to the New York Times crossword of March 31st, 1997. Or you can use the search form below to find the answer (no matter if its New York Times Crossword or any other crossword).
|New York Times crossword of March 31st, 1997 other clues
|'Frasier' character
|'Nightline' host Koppel
|'The Spectator' essayist
|'We ___ Not Alone' (1939 film)
|'___ in Toyland'
|Actor Liam
|Actress Susan
|April check payee: Abbr.
|Auld lang ___
|Ayatollah's land
|Batman's sidekick
|Bean counter, for short
|Cause friction
|Certain soft drink
|Civil War alliance: Abbr.
|Coffee maker
|College area
|Computer-telephone link
|Cough drop ingredient
|Dawn goddess
|Dry, as wine
|Employee's reward
|Formal headgear
|Former pro footballer, briefly
|Gallows loops
|Hotel employee
|Hotelier Helmsley
|Jakarta's island
|Jelly used for fuel
|Like a win-win situation
|Like mountains in winter
|Loose, as shoelaces
|Lover of Sir Lancelot
|Lucy's husband
|Mideast canal
|Miss's equivalent, in a saying
|Muppeteer Henson
|Not at work
|Open up a rip again
|Opposite of no-nos
|Papal vestment
|Part of Q.E.D.
|Person from Muscat
|Place for grandma's trunk
|Polio vaccine developer
|Prof's deg.
|Red wine
|Short sock
|Sign painter's aid
|Slippery fish
|Small allowance for a schoolchild
|Small egg
|Some New Year's resolutions
|Stan's partner, for short
|Take it easy
|Took out
|Treasure container
|Very dry
|What everything's coming up, in song
|Words mouthed at a TV camera
|Yemeni port
|Yorkshire city
|___ Brewery Co., of Detroit
We offer support and help with a wide range of crosswords and are guaranteed to make sure you complete everything; the site is also updated regularly to make sure that all of our answers are correct and to add more crosswords to the ever growing list.
If there is any problem with the answer, please contact us! We will fix the problem.


text:
X-Suit NIR Biliary Metallic Stents
Metal Stent
X-Suit NIR Biliary Metallic Stents
Olympus X-Suit NIR Biliary Metal Stents feature a unique NIRflex cell design provides superior radial support and excellent conformability. These single-use stents are designed for easy placement at a precisely targeted position and exhibit virtually no foreshortening. Distinctive color markings on the introducer help maintain endoscopic visualization for proper placement of the stent. The stents are available in both 8 and 10 mm outer diameters and in 4, 6, 8, and 10 cm working lengths.
Key Benefits
- Anatomic conformity: The NIRflex cell design features narrow strut rings for exceptional flexibility and wide strut rings for superior radial support. The result is a stent with superior radial support and excellent conformability.
- Superior design: The stents are designed to exhibit virtually no foreshortening and to deliver consistent deployment force from start to finish.
- Precise stent placement: Distinctive color markings on the introducer help maintain endoscopic visualization for proper placement of the stent.
Product Support
Minimum Channel Size: 3.2 mm
Working Length: 190 cm
Stent Outer Diameters: 8, 10 mm
Stent Lengths: 4, 6, 8, 10 cm
Delivery Catheter: 7.5 Fr.
Package: 1 per box, sterile
Use: Single use
For detailed specifications please contact customer service for assistance.
Olympus Training & Proper Use
Olympus offers a variety of educational opportunities for medical and surgical healthcare professionals.
Peer-To-Peer Training
Our Professional Education Program provides multiple types of peer-to-peer training in order to meet the specific educational needs of physicians and nurses focused on the safe and effective use of Olympus products.
Olympus University
Olympus Professional Education also offers training programs through Olympus University (OU). Geared toward nurses, reprocessing technicians and biomeds, many of the OU courses are available for nursing contact hour continuing education credit.
Visit Olympus University


text:
The Color Wheel
Why do blue and yellow look good together? What makes green and orange an appealing pair? The secret to why some color combos sail and others fail all comes down to color theory -- and that brilliant tool, the color wheel.
A favorite of designers and artists, the wheel makes color relationships easy to see by dividing the spectrum into 12 basic hues: three primary colors, three secondaries, and six tertiaries.
Primary colors are red, blue, and yellow. These colors are pure -- you can't create them from other colors, and all other colors are created from them. Secondary colors are orange, green, and violet. They line up between the primaries on the color wheel because they are formed when equal parts of two primary colors are combined. Tertiary colors are formed by mixing a primary color with a secondary color next to it on the color wheel. With each blending -- primary with primary, then primary with secondary -- the resulting hues become less vivid, as seen in the color wheel opposite.
How the Color Wheel Works
Using the Color Wheel to Build Color Schemes
The color wheel helps you mix colors to get palettes with varying degrees of contrast. Four common types of color schemes:
Monochromatic Scheme: These tone-on-tone combinations use several shades (adding black) and tints (adding white) of a single hue for a subtle palette. Think pale blue, sky blue, and navy.
Analogous Scheme: For a bit more contrast, an analogous palette includes colors found side by side on the wheel, such as orange, yellow, and green, for a colorful but relaxing feel.
Contrast: A triad creates an adventurous palette by using three hues evenly spaced on the wheel, such as blue-green, red-violet, and yellow-orange, for vivid contrast with balanced colors.
Complementary Scheme: This is the most dynamic -- yet simple -- color scheme. Using two hues opposite each other on the color wheel, such as blue and orange, is guaranteed to add energy to any room.
Color can also affect emotional responses and create a mood. Greens tend to soothe, for instance, while yellows are uplifting and energetic. Bold reds are passionate and daring, but soft pink (a tint of red) is considered sweet and delicate. Blues are perceived as calming and quiet; oranges are warm and cozy; and purple, a truly complex color, can be seen as sexy or spiritual. Colors are considered warm or cool because of association. In our minds we compare reds, oranges, and yellows with the warmth of the sun and fire. Blues, greens, and violets are cool because of their association with water, sky, and foliage. As you create a color palette, your scheme should never be all warm colors or all cool colors. Let one dominate and set the overall tone of the room, but be sure to include elements that offer contrast.
Color Terms
Analogous: Neighbors on the color wheel
Chroma: A color's brightness or dullness
Complementary: Opposites on the color wheel, which appear brighter when they are used together (examples: yellow and purple, red and green, blue and orange)
Neutral: Black, white, brown, and gray
Secondary: A combination of equal parts of two primary colors (secondary colors are green, orange, purple)
Shade: Any color with black added; also refers to slight variations in a color
Primary: Pure colors -- red, yellow, and blue -- that combine to create all other colors on the wheel
Split Complementary: The grouping of a color with the two hues analogous to its complementary color (yellow with red-violet and blue-violet, for example)
Triad: Any three colors equally spaced on the color wheel, one of which usually takes precedence in a color scheme (yellow-orange, blue-green, and red-violet, for example)
Tertiary: A combination of equal parts of a primary and a secondary color
Tint: Any color with white added
Tone: A color's intensity -- its degree of lightness or darkness


text:
Download our entire HD & 4K teen archive in just moments. Select a membership plan below.
Winter may be her name, but she is definitely hot like Summer! horny Winter wastes no time, pulling her cotton panties aside she starts flicking that little clit! After a quick peek at her perky boobs, her heart shaped butt is in the air and the lingerie are down. Grabbing her purple vibe from the bed-stand she presses it deep into her vag! Not satisfied with something so mini she grabs the studded glass dildoand plows herself doggy! Pounding herself with the studded dildo, she teases her clit with the purple vibe! Laying down she keeps banging her moist hole, still playing the vibe over her clit!Read more
Categories Blonde, HD, Pussy Masturbation, Small Tits, Solo, Teen (18-19), Vaginal Toys, show tags
Teen Girls uses cookies. To know more, read our Privacy policy.


text:
Good server with some nice people. Admin is a star and has been more than available during most hours of the day even though he has a job! 3 cheers for Devious!Come join us!
I'm not sure if this is the right location, but I cannot seem to connect to the server. During the Loading..., it simply does not load. Eventually I get kicked from the server. Did I do something wrong when installing the mods? I verified and then copied the mod files from the download in the main post (1.3).