| Class | ActionController::AbstractRequest |
| In: |
vendor/rails/actionpack/lib/action_controller/deprecated_request_methods.rb
vendor/rails/actionpack/lib/action_controller/request.rb |
| Parent: | Object |
Subclassing AbstractRequest makes these methods available to the request objects used in production and testing, CgiRequest and TestRequest
| env | [R] | Returns the hash of environment variables for this request, such as { ‘RAILS_ENV’ => ‘production’ }. |
Returns the accepted MIME type for the request
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 72 72: def accepts 73: @accepts ||= 74: if @env['HTTP_ACCEPT'].to_s.strip.empty? 75: [ content_type, Mime::ALL ] 76: else 77: Mime::Type.parse(@env['HTTP_ACCEPT']) 78: end 79: end
Determine whether the body of a HTTP call is URL-encoded (default) or matches one of the registered param_parsers.
For backward compatibility, the post format is extracted from the X-Post-Data-Format HTTP header if present.
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 53 53: def content_type 54: @content_type ||= 55: begin 56: content_type = @env['CONTENT_TYPE'].to_s.downcase 57: 58: if x_post_format = @env['HTTP_X_POST_DATA_FORMAT'] 59: case x_post_format.to_s.downcase 60: when 'yaml' 61: content_type = 'application/x-yaml' 62: when 'xml' 63: content_type = 'application/xml' 64: end 65: end 66: 67: Mime::Type.lookup(content_type) 68: end 69: end
Is this a DELETE request? Equivalent to request.method == :delete
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 39 39: def delete? 40: method == :delete 41: end
Returns the domain part of a host, such as rubyonrails.org in "www.rubyonrails.org". You can specify a different tld_length, such as 2 to catch rubyonrails.co.uk in "www.rubyonrails.co.uk".
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 111 111: def domain(tld_length = 1) 112: return nil if !/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/.match(host).nil? or host.nil? 113: 114: host.split('.').last(1 + tld_length).join('.') 115: end
Is this a POST request formatted as XML or YAML?
# File vendor/rails/actionpack/lib/action_controller/deprecated_request_methods.rb, line 20 20: def formatted_post? 21: post? && (post_format == :yaml || post_format == :xml) 22: end
Is this a GET request? Equivalent to request.method == :get
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 24 24: def get? 25: method == :get 26: end
Is this a HEAD request? Equivalent to request.method == :head
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 44 44: def head? 45: method == :head 46: end
Returns the host for this request, such as example.com.
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 243 243: def host 244: end
Returns a host:port string for this request, such as example.com or example.com:8080.
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 205 205: def host_with_port 206: host + port_string 207: end
Returns the HTTP request method as a lowercase symbol (:get, for example)
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 17 17: def method 18: @request_method ||= (!parameters[:_method].blank? && @env['REQUEST_METHOD'] == 'POST') ? 19: parameters[:_method].to_s.downcase.to_sym : 20: @env['REQUEST_METHOD'].downcase.to_sym 21: end
Returns both GET and POST parameters in a single hash.
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 12 12: def parameters 13: @parameters ||= request_parameters.update(query_parameters).update(path_parameters).with_indifferent_access 14: end
Returns the interpreted path to requested resource after all the installation directory of this application was taken into account
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 160 160: def path 161: path = (uri = request_uri) ? uri.split('?').first : '' 162: 163: # Cut off the path to the installation directory if given 164: root = relative_url_root 165: path[0, root.length] = '' if root 166: path || '' 167: end
Returns a hash with the parameters used to form the path of the request
Example:
{:action => 'my_action', :controller => 'my_controller'}
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 224 224: def path_parameters 225: @path_parameters ||= {} 226: end
Returns the port number of this request as an integer.
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 185 185: def port 186: @port_as_int ||= @env['SERVER_PORT'].to_i 187: end
Returns a port suffix like ":8080" if the port number of this request is not the default HTTP port 80 or HTTPS port 443.
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 199 199: def port_string 200: (port == standard_port) ? '' : ":#{port}" 201: end
Is this a POST request? Equivalent to request.method == :post
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 29 29: def post? 30: method == :post 31: end
Determine whether the body of a HTTP call is URL-encoded (default) or matches one of the registered param_parsers.
For backward compatibility, the post format is extracted from the X-Post-Data-Format HTTP header if present.
# File vendor/rails/actionpack/lib/action_controller/deprecated_request_methods.rb, line 8 8: def post_format 9: case content_type.to_s 10: when 'application/xml' 11: :xml 12: when 'application/x-yaml' 13: :yaml 14: else 15: :url_encoded 16: end 17: end
Return ‘https://’ if this is an SSL request and ‘http://’ otherwise.
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 150 150: def protocol 151: ssl? ? 'https://' : 'http://' 152: end
Is this a PUT request? Equivalent to request.method == :put
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 34 34: def put? 35: method == :put 36: end
Receive the raw post data. This is useful for services such as REST, XMLRPC and SOAP which communicate over HTTP POST but don’t use the traditional parameter format.
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 129 129: def raw_post 130: @env['RAW_POST_DATA'] 131: end
Returns the path minus the web server relative installation directory. This can be set with the environment variable RAILS_RELATIVE_URL_ROOT. It can be automatically extracted for Apache setups. If the server is not Apache, this method returns an empty string.
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 173 173: def relative_url_root 174: @@relative_url_root ||= case 175: when @env["RAILS_RELATIVE_URL_ROOT"] 176: @env["RAILS_RELATIVE_URL_ROOT"] 177: when server_software == 'apache' 178: @env["SCRIPT_NAME"].to_s.sub(/\/dispatch\.(fcgi|rb|cgi)$/, '') 179: else 180: '' 181: end 182: end
Determine originating IP address. REMOTE_ADDR is the standard but will fail if the user is behind a proxy. HTTP_CLIENT_IP and/or HTTP_X_FORWARDED_FOR are set by proxies so check for these before falling back to REMOTE_ADDR. HTTP_X_FORWARDED_FOR may be a comma- delimited list in the case of multiple chained proxies; the first is the originating IP.
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 95 95: def remote_ip 96: return @env['HTTP_CLIENT_IP'] if @env.include? 'HTTP_CLIENT_IP' 97: 98: if @env.include? 'HTTP_X_FORWARDED_FOR' then 99: remote_ips = @env['HTTP_X_FORWARDED_FOR'].split(',').reject do |ip| 100: ip =~ /^unknown$|^(10|172\.(1[6-9]|2[0-9]|30|31)|192\.168)\./i 101: end 102: 103: return remote_ips.first.strip unless remote_ips.empty? 104: end 105: 106: @env['REMOTE_ADDR'] 107: end
Returns the request URI correctly, taking into account the idiosyncracies of the various servers.
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 135 135: def request_uri 136: if uri = @env['REQUEST_URI'] 137: (%r{^\w+\://[^/]+(/.*|$)$} =~ uri) ? $1 : uri # Remove domain, which webrick puts into the request_uri. 138: else # REQUEST_URI is blank under IIS - get this from PATH_INFO and SCRIPT_NAME 139: script_filename = @env['SCRIPT_NAME'].to_s.match(%r{[^/]+$}) 140: uri = @env['PATH_INFO'] 141: uri = uri.sub(/#{script_filename}\//, '') unless script_filename.nil? 142: unless (env_qs = @env['QUERY_STRING']).nil? || env_qs.empty? 143: uri << '?' << env_qs 144: end 145: uri 146: end 147: end
Returns the lowercase name of the HTTP server software.
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 229 229: def server_software 230: (@env['SERVER_SOFTWARE'] && /^([a-zA-Z]+)/ =~ @env['SERVER_SOFTWARE']) ? $1.downcase : nil 231: end
Is this an SSL request?
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 155 155: def ssl? 156: @env['HTTPS'] == 'on' || @env['HTTP_X_FORWARDED_PROTO'] == 'https' 157: end
Returns the standard port number for this request’s protocol
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 190 190: def standard_port 191: case protocol 192: when 'https://' then 443 193: else 80 194: end 195: end
Returns all the subdomains as an array, so ["dev", "www"] would be returned for "dev.www.rubyonrails.org". You can specify a different tld_length, such as 2 to catch ["www"] instead of ["www", "rubyonrails"] in "www.rubyonrails.co.uk".
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 120 120: def subdomains(tld_length = 1) 121: return [] unless host 122: parts = host.split('.') 123: parts[0..-(tld_length+2)] 124: end
The same as path_parameters with explicitly symbolized keys
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 215 215: def symbolized_path_parameters 216: @symbolized_path_parameters ||= path_parameters.symbolize_keys 217: end
Returns true if the request’s "X-Requested-With" header contains "XMLHttpRequest". (The Prototype Javascript library sends this header with every Ajax request.)
# File vendor/rails/actionpack/lib/action_controller/request.rb, line 84 84: def xml_http_request? 85: not /XMLHttpRequest/i.match(@env['HTTP_X_REQUESTED_WITH']).nil? 86: end
Is this a POST request formatted as XML?
# File vendor/rails/actionpack/lib/action_controller/deprecated_request_methods.rb, line 25 25: def xml_post? 26: post? && post_format == :xml 27: end


?Eftun/aed
fa
"«»*•»«,
nm
THE
NEW
YORK
BOTANICAL
GARDEN
PLANTS
OF
COOPER’S
RANCH,
BASE
OF
EL
YUNQUE
MT.,
BARACOA,
CUBA
4
~y
ó
L.
M.
UNDERWOOD
&
F.
S.
EARLE,
COLLEOTORS
^
MARCH,
1903
0-^0
DET.
BY
MILDRED
E.
MATHIAS
01501082
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


Hello World!
My name is Santiago Múnera and I'm glad that you can see a glimpse of what I am and what I do by just staring at this website. You can get to know me currently as a computer and systems engineer student at La Universidad De Los Andes, located in Bogotá, Colombia.
To start, just press the green button... Then, explore!:
Welcome to my website!


Load and Play Audio Files on the Server
Open an audio file from the server side and play/stop it by clicking the buttons.
Load
Play
Stop


Fecha_Creacion: 2018-04-15T17:13:54.071Z
Dimension: Dimension C-137
Id_Locacion: 70
Nombre: Snuffles' Dream
Residentes: ['https://rickandmortyapi.com/api/character/397', 'https://rickandmortyapi.com/api/character/398']
Tipo: Dream
URL: https://rickandmortyapi.com/api/location/70


Apply sound effects to your talk!
Warning for audio feedback, use headphones to prevent it.
Select a sound effect (can be changed at any time):
Echo
Cathedral
Spring


The best iPhone of 2019 may go on sale this Black Friday so check here
Source: Karen Freeman/iMore
Best iPhone iMore 2019
The phone you carry with you every day is your most important and most personal device. It's got to be fast, reliable, and have the most advanced features you need every day. Since Apple changed the landscape of iPhones in 2019, the iPhone 11 is now the best iPhone for most people.
- Best Overall: iPhone 11
- Best on a Budget: iPhone 8
- Best for Photographers: iPhone 11 Pro
- Best for kids: iPhone XR
This Black Friday, we're optimistic that we'll see decent discounts across the entire iPhone lineup, from the new iPhone 11 to older models. If you're on the lookout for a new iPhone, this buyer's guide will help you make the right choice. It might be smart to hold out just a little bit longer if you can because, with Black Friday just a week away, there's a good chance you'll see a drop in price that you won't normally get. The iMore deals team will be keeping an eye on all the possible discounts for the iPhone in the coming weeks and will let you know as soon as the prices drop. Be sure to bookmark this page and check back often because here's where you'll find the best iPhone deals for Black Friday.
Best Overall: iPhone 11
Source: iMore
The iPhone 11 is practically perfect in every way. It has a 12MP dual-camera system with wide and ultra-wide lenses, Apple's fastest A13 Bionic chip, a Liquid Retina HD LCD display, and a 6.1" screen size.
It uses Apple's advanced Face ID biometric scanning (which also means the True Depth FaceTime camera), supports Animoji, slo-mo selfies (or, "slofies" as Apple has marketed), 4K video recording support, Portrait mode for the front and back-facing cameras (including non-human subjects), Night mode, and a whole lot more.
The iPhone 11 has nearly every single amazing feature the iPhone 11 Pro has except the three-camera system (which includes a telephoto lens) and the Super Retina OLED display. At a fraction of the price of the Pro model, this is why the iPhone 11 is the best iPhone for most people.
Pros:
- Dual-camera system
- Nearly all the same features as the iPhone 11 Pro
- Six different colors
- Really great price
Cons:
- No telephoto lens
- LCD screen instead of OLED
Best Overall
iPhone 11
Practically a Pro but at a lower price.
The iPhone 11 is the right phone at the right price for most people and comes in an array of great colors.
Best on a Budget: iPhone 8
Source: Rene Ritchie/iMore
If your pocketbook has you restricted, the lowest-priced iPhone is the 4.7" iPhone 8. It sports Apple's A11 Bionic chip, a 12MP dual-camera system with wide and telephoto lenses, 4K video recording, and plenty of advanced technology. It's not Apple's latest and greatest, but it will continue to receive software support for years to come, and you can get it for a song (comparatively for an iPhone). This is the only phone with a Home button in Apple's current lineup. So if you prefer fingerprint scanning to facial scanning, this is the iPhone for you.
Pros:
- Least expensive iPhone
- Home button
- Telephoto lens
Cons:
- 2-year old processor chip
- Missing a lot of the new camera features of the iPhone 11
Best on a Budget
iPhone 8
The perfect entry-level iPhone.
If you're just entering the smartphone game or you're upgrading from the iPhone 6, this is a fantastic iPhone at an incredibly low price.
Best for Photographers: iPhone 11 Pro
Source: Rene Ritchie/iMore
The one thing that makes the iPhone 11 Pro noticeably different than the iPhone 11 is in the camera system. It's a 12MP triple-camera system with wide, ultra-wide, and telephoto lenses. With three lenses, you can zoom in or out 2x and digitally zoom up to 10x. It's any photographer's dream and might even replace some people's daily camera carry. If you want the absolute most advanced camera system, this is the pick for you. The iPhone 11 Pro and iPhone 11 Pro Max also have the longest battery life of any iPhone ever by a lot.
As a secondary note, if you prefer a slim iPhone design and don't mind spending the extra cash, the iPhone 11 Pro is also the thinnest of the entire lineup.
Pros:
- Triple-lens camera
- Super long battery life
- Super Retina OLED screen
Cons:
- Most expensive iPhone
- No bright color options
Best for Photographers
iPhone 11 Pro
Most advanced everything at a premium price.
If money is no issue and you really want that triple-camera system, the iPhone 11 Pro has it all and then some.
Best for kids: iPhone XR
Source: iMore
Let's face it; your kids are going to be secretly disappointed (or maybe openly disappointed) if you buy them an iPhone 8. It's a great phone at a great price, but they want the new hotness. The iPhone XR was Apple's best-selling iPhone in 2019 and was the most popular model until the iPhone 11 came along. It comes in six bright colors, supports Face ID and Animoji and Memoji, features Portrait mode (though only for humans), and is a great first iPhone for your kids.
Pros:
- Great price
- Bright colors
- Face ID
Cons:
- Not an iPhone 11
Best for kids
iPhone XR
Thanks, mom and dad. You're the best!
The iPhone XR hugely popular and comes with some of the best features you can get right now. Your kids will love it.
Bottom line
Because the iPhone 11 has all of the same features as the iPhone 11 Pro except the telephoto lens and the Super Retina display, but at a fraction of the price of the Pro model, it's hands-down the best iPhone for most people and our pick this year.
If you want the most advanced camera system in an iPhone, and arguably in any phone, you're going to want the iPhone 11 Pro. It's got the longest battery life of any iPhone every by a lot and will make any of your pics look practically professional.
Some advice for shopping for Black Friday iPhone deals
An iPhone is a personal thing; it's so personal that it knows more about you than your spouse or your parents. If you're upgrading from an iPhone SE, the iPhone 11 Pro is the closest in terms of size. It's thinner than any other model. If you want a big screen, an iPhone 8 Plus is a bargain option, but the iPhone 11 Pro Max, with its nearly edge-to-edge display, has the largest screen real estate of any iPhone.
For Black Friday, you're not going to see a whole lot of big discounts on the iPhone 11 lineup, but there's a good chance that retailers and carriers that still have older models are going to offer special package discounts. You could get an iPhone 8 for even lower than the already low price it already sells for.
We recommend keeping a close eye on carrier sales. If you have or want a Verizon, AT&T, Sprint, or T-Mobile plan, you may find an incredible bargain on Black Friday through one of these carriers.
Of course, the iMore deals team will be scouring the web during the entire Black Friday weekend (let's be honest, it's more like a week), looking for the best deals on iPhone devices, which we'll be sure to share with you. So keep this page bookmarked and check back often to find the best deals on all models of iPhone this Black Friday.
Credits — The team that worked on this guide
Lory Gil is the Managing Editor of iMore and knows here way around an iPhone. She's known as the four-inch iPhone fan (R.I.P.).
We may earn a commission for purchases using our links. Learn more.


Revolving Digits
Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 1105 Accepted Submission(s): 318
Problem Description
One day Silence is interested in revolving the digits of a positive integer. In the revolving operation, he can put several last digits to the front of the integer. Of course, he can put all the digits to the front, so he will get the integer itself. For example,
he can change 123 into 312, 231 and 123. Now he wanted to know how many different integers he can get that is less than the original integer, how many different integers he can get that is equal to the original integer and how many different integers he can
get that is greater than the original integer. We will ensure that the original integer is positive and it has no leading zeros, but if we get an integer with some leading zeros by revolving the digits, we will regard the new integer as it has no leading zeros.
For example, if the original integer is 104, we can get 410, 41 and 104.
he can change 123 into 312, 231 and 123. Now he wanted to know how many different integers he can get that is less than the original integer, how many different integers he can get that is equal to the original integer and how many different integers he can
get that is greater than the original integer. We will ensure that the original integer is positive and it has no leading zeros, but if we get an integer with some leading zeros by revolving the digits, we will regard the new integer as it has no leading zeros.
For example, if the original integer is 104, we can get 410, 41 and 104.
Input
The first line of the input contains an integer T (1<=T<=50) which means the number of test cases.
For each test cases, there is only one line that is the original integer N. we will ensure that N is an positive integer without leading zeros and N is less than 10^100000.
For each test cases, there is only one line that is the original integer N. we will ensure that N is an positive integer without leading zeros and N is less than 10^100000.
Output
For each test case, please output a line which is "Case X: L E G", X means the number of the test case. And L means the number of integers is less than N that we can get by revolving digits. E means the number of integers is equal to N. G means the number of
integers is greater than N.
integers is greater than N.
Sample Input
1 341
Sample Output
Case 1: 1 1 1
题意:给定一个数字<=10^100000,一次将该数的第一位放到放到最后一位,求所有组成的不同的数比原数小的个数,相等的个数,大的个数
分析:由于输入的数太大了,只能当作字符串处理,将输入的原串粘贴在后面，这样就可以对原串进行EKMP,最终只要统计从第i个位置开始的extend[i],如果>=len则从第i个位置开始的组成的数与原数相等,否则只要比较s[i]与s[i+next[i]]即可
#include<iostream> #include<cstdio> #include<cstdlib> #include<cstring> #include<string> #include<queue> #include<algorithm> #include<map> #include<iomanip> #define INF 999999999 using namespace std; const int MAX=100000+10; char s[MAX*2]; int next[MAX]; void get_next(char *a,int len){ int i=-1,j=0; next[0]=-1; while(j<len){ if(i == -1 || a[i] == a[j])next[++j]=++i; else i=next[i]; } } void get_extend(char *a,int len){ int k=0,i=1; next[0]=len; while(k+1<len && a[k] == a[k+1])++k; next[1]=k; k=1; while(++i<len/2){//只需要求到原串的长度即可 int maxr=k+next[k]-1; next[i]=min(next[i-k],max(maxr-i+1,0)); while(i+next[i]<len && a[next[i]] == a[i+next[i]])++next[i]; if(i+next[i]>k+next[k])k=i; } } int main(){ int t,num=0; cin>>t; while(t--){ scanf("%s",s); int len=strlen(s); get_next(s,len); int temp=len%(len-next[len]) == 0?len/(len-next[len]):1;//求循环节循环了几次 for(int i=0;i<=len;++i)s[i+len]=s[i]; get_extend(s,len+len); int a=0,b=0,c=0; for(int i=0;i<len;++i){ if(next[i]>=len)++b;//表示等于原串的 else if(s[next[i]]<s[i+next[i]])++c;//表示大于原串的 else ++a;//表示小于原串的 } cout<<"Case "<<++num<<": "<<a/temp<<' '<<b/temp<<' '<<c/temp<<endl; } return 0; }
版权声明：本文为博主原创文章，未经博主允许不得转载。
(adsbygoogle = window.adsbygoogle || []).push({});
基努给我的感觉一直是彬彬有礼
基努给我的感觉一直是彬彬有礼
基努给我的感觉一直是彬彬有礼
基努给我的感觉一直是彬彬有礼
基努给我的感觉一直是彬彬有礼
基努给我的感觉一直是彬彬有礼
基努给我的感觉一直是彬彬有礼
基努给我的感觉一直是彬彬有礼
基努给我的感觉一直是彬彬有礼
基努给我的感觉一直是彬彬有礼
基努给我的感觉一直是彬彬有礼
基努给我的感觉一直是彬彬有礼
基努给我的感觉一直是彬彬有礼
基努给我的感觉一直是彬彬有礼
聚会的时候，别人根本不理会我这个大学生
聚会的时候，别人根本不理会我这个大学生
聚会的时候，别人根本不理会我这个大学生
聚会的时候，别人根本不理会我这个大学生


enable print fname
This command opens the output file fname
that will contain the instructions in GrADS metacode format to create a hardcopy of the graphical display. Any existing contents of fname
will be lost.
The output file fname
is referred to as a GrADS metafile.
Creating a GrADS metafile for vector-graphic hardcopy involves four steps:
1. Open the metafile with the enable print
command
2. Create the graphical display that you want to print
3. Issue the print
command. For multiple images in your metafile, use clear
and then print
again.
4. Close the metafile with the disable print
command
After you have created a GrADS metafile, you can
1. convert it to postscript using the external utility gxps
2.
convert it to encapsulated postscript using gxeps
or you can
3.
display it using the external utilities gxtran
or gv32.exe
(for MS Windows)


The cmdshell module uses the paramiko package to create SSH connections to the servers that are represented by instance objects. The module has functions for running commands, managing files, and opening interactive shell sessions over those connections.
This object has a subset of the variables that are normally in a boto.manage.server.Server object. You can use this FakeServer object to create a boto.manage.SSHClient object if you don’t have a real Server object.
| Variables: |
|
|---|
| Variables: |
|
|---|
Check for the specified path, or check a file at the specified path.
| Return type: | boolean |
|---|---|
| Returns: | If the path or the file exist, the function returns True. |
Copy a file from one directory to another.
Check the specified path to determine if it is a directory.
| Return type: | boolean |
|---|---|
| Returns: | Returns True if the path is an existing directory. |
List all of the files and subdirectories at the specified path.
| Return type: | list |
|---|---|
| Returns: | Return a list containing the names of the entries in the directory given by path. |
Copy a file from one directory to another.
Open a subprocess and run a command on the local host.
| Return type: | tuple |
|---|---|
| Returns: | This function returns a tuple that contains an integer status and a string with the combined stdout and stderr output. |
This class creates a paramiko.SSHClient() object that represents a session with an SSH server. You can use the SSHClient object to send commands to the remote host and manipulate files on the remote host.
| Variables: |
|
|---|
Close an SSH session and any open channels that are tied to it.
Connect to an SSH server and authenticate with it.
| Parameters: | num_retries (int) – The maximum number of connection attempts. |
|---|
Check the remote host for the specified path, or a file at the specified path. This function returns 1 if the path or the file exist on the remote host, and returns 0 if the path or the file does not exist on the remote host.
| Parameters: | path (string) – The path to the directory or file that you want to check. |
|---|---|
| Return type: | integer |
| Returns: | If the path or the file exist, the function returns 1. If the path or the file do not exist on the remote host, the function returns 0. |
Open an SFTP session on the remote host, and copy a file from the remote host to the specified path on the local host.
| Parameters: |
|---|
Check the specified path on the remote host to determine if it is a directory.
| Parameters: | path (string) – The path to the directory that you want to check. |
|---|---|
| Return type: | integer |
| Returns: | If the path is a directory, the function returns 1. If the path is a file or an invalid path, the function returns 0. |
List all of the files and subdirectories at the specified path on the remote host.
| Parameters: | path (string) – The base path from which to obtain the list. |
|---|---|
| Return type: | list |
| Returns: | A list of files and subdirectories at the specified path. |
Open an SFTP session to the remote host, and open a file on that host.
| Parameters: | |
|---|---|
| Return type: | paramiko.sftp_file.SFTPFile |
| Returns: | A paramiko proxy object for a file on the remote server. |
Open an SFTP session on the SSH server.
| Return type: | paramiko.sftp_client.SFTPClient |
|---|---|
| Returns: | An SFTP client object. |
Open an SFTP session on the remote host, and copy a file from the local host to the specified path on the remote host.
| Parameters: |
|---|
Run a command on the remote host.
| Parameters: | command (string) – The command that you want to send to the remote host. |
|---|---|
| Return type: | tuple |
| Returns: | This function returns a tuple that contains an integer status, the stdout from the command, and the stderr from the command. |
Request a pseudo-terminal from a server, and execute a command on that server.
| Parameters: | command (string) – The command that you want to run on the remote host. |
|---|---|
| Return type: | paramiko.channel.Channel |
| Returns: | An open channel object. |
Start an interactive shell session with the remote host.
Create and return an SSHClient object given an instance object.
| Parameters: |
|
|---|
Connect to the specified server.
| Returns: | If the server is local, the function returns a boto.manage.cmdshell.LocalClient object. If the server is remote, the function returns a boto.manage.cmdshell.SSHClient object. |
|---|


TO THE
TRAILS
Boulder County
Find by Length
Toggle Dropdown
Up to 2 Miles
2 to 5 Miles
5 to 10 Miles
Over 10 Miles
Clear Search


|
SGI®
Technology Solutions enable you to accomplish the next
great technology breakthroughs of the
21st century.
You can be confident that our technical experts will
architect, implement, and support superior, end-to-end
solutions tailored to your unique workflow and technology
requirements. We excel in solutions, services, and support
for high performance computing, management of complex
data, and advanced visualization.
Our innovative products are empowering a world of
innovation and discovery and can have a dramatic
impact on the way you do business. To ensure
your success, SGI Technology Solutions offers
total integrated solutions as well as a broad
range of specific services to accelerate productivity
and maximize system performance.
See how SGI
Professional Services,
Managed Services, and
Support Services
can keep you at the forefront of your industry and deliver
more return on your technology investment.
For additional information, please visit us on the
web page at
www.sgi.com/support/
or call 1-800-800-7441. |


npmrc
The npm config filesTable of contents
Description
npm gets its config settings from the command line, environment
variables, and npmrc
files.
The npm config
command can be used to update and edit the contents
of the user and global npmrc files.
For a list of available configuration options, see config.
Files
The four relevant files are:
- per-project config file (/path/to/my/project/.npmrc)
- per-user config file (~/.npmrc)
- global config file ($PREFIX/etc/npmrc)
- npm builtin config file (/path/to/npm/npmrc)
All npm config files are an ini-formatted list of key = value
parameters. Environment variables can be replaced using
${VARIABLE_NAME}
. For example:
prefix = ${HOME}/.npm-packages
Each of these files is loaded, and config options are resolved in priority order. For example, a setting in the userconfig file would override the setting in the globalconfig file.
Array values are specified by adding “[]” after the key name. For example:
key[] = "first value"
key[] = "second value"
Comments
Lines in .npmrc
files are interpreted as comments when they begin with a ;
or #
character. .npmrc
files are parsed by npm/ini, which specifies this comment syntax.
For example:
# last modified: 01 Jan 2016
; Set a new registry for a scoped package
@myscope:registry=https://mycustomregistry.example.org
Per-project config file
When working locally in a project, a .npmrc
file in the root of the
project (ie, a sibling of node_modules
and package.json
) will set
config values specific to this project.
Note that this only applies to the root of the project that you’re running npm in. It has no effect when your module is published. For example, you can’t publish a module that forces itself to install globally, or in a different location.
Additionally, this file is not read in global mode, such as when running
npm install -g
.
Per-user config file
$HOME/.npmrc
(or the userconfig
param, if set in the environment
or on the command line)
Global config file
$PREFIX/etc/npmrc
(or the globalconfig
param, if set above):
This file is an ini-file formatted list of key = value
parameters.
Environment variables can be replaced as above.
Built-in config file
path/to/npm/itself/npmrc
This is an unchangeable “builtin” configuration file that npm keeps
consistent across updates. Set fields in here using the ./configure
script that comes with npm. This is primarily for distribution
maintainers to override default configs in a standard and consistent
manner.


#include <tuner_api.h>
Public Member Functions | |
| Tuner (const PlatformIndex platform, const DeviceIndex device) | |
| Tuner (const PlatformIndex platform, const DeviceIndex device, const ComputeAPI computeAPI) | |
| Tuner (const PlatformIndex platform, const DeviceIndex device, const ComputeAPI computeAPI, const uint32_t computeQueueCount) | |
| ~Tuner () | |
| KernelId | addKernel (const std::string &source, const std::string &kernelName, const DimensionVector &globalSize, const DimensionVector &localSize) |
| KernelId | addKernelFromFile (const std::string &filePath, const std::string &kernelName, const DimensionVector &globalSize, const DimensionVector &localSize) |
| void | setKernelArguments (const KernelId id, const std::vector< ArgumentId > &argumentIds) |
| void | addParameter (const KernelId id, const std::string ¶meterName, const std::vector< size_t > ¶meterValues) |
| void | addParameterDouble (const KernelId id, const std::string ¶meterName, const std::vector< double > ¶meterValues) |
| void | addParameterPack (const KernelId id, const std::string &packName, const std::vector< std::string > ¶meterNames) |
| void | setThreadModifier (const KernelId id, const ModifierType modifierType, const ModifierDimension modifierDimension, const std::vector< std::string > ¶meterNames, const std::function< size_t(const size_t, const std::vector< size_t > &)> &modifierFunction) |
| void | setThreadModifier (const KernelId id, const ModifierType modifierType, const ModifierDimension modifierDimension, const std::string ¶meterName, const ModifierAction modifierAction) |
| void | setLocalMemoryModifier (const KernelId id, const ArgumentId argumentId, const std::vector< std::string > ¶meterNames, const std::function< size_t(const size_t, const std::vector< size_t > &)> &modifierFunction) |
| void | addConstraint (const KernelId id, const std::vector< std::string > ¶meterNames, const std::function< bool(const std::vector< size_t > &)> &constraintFunction) |
| void | setTuningManipulator (const KernelId id, std::unique_ptr< TuningManipulator > manipulator) |
| void | setTuningManipulatorSynchronization (const KernelId id, const bool flag) |
| KernelId | addComposition (const std::string &compositionName, const std::vector< KernelId > &kernelIds, std::unique_ptr< TuningManipulator > manipulator) |
| void | setCompositionKernelThreadModifier (const KernelId compositionId, const KernelId kernelId, const ModifierType modifierType, const ModifierDimension modifierDimension, const std::vector< std::string > ¶meterNames, const std::function< size_t(const size_t, const std::vector< size_t > &)> &modifierFunction) |
| void | setCompositionKernelThreadModifier (const KernelId compositionId, const KernelId kernelId, const ModifierType modifierType, const ModifierDimension modifierDimension, const std::string ¶meterName, const ModifierAction modifierAction) |
| void | setCompositionKernelLocalMemoryModifier (const KernelId compositionId, const KernelId kernelId, const ArgumentId argumentId, const std::vector< std::string > ¶meterNames, const std::function< size_t(const size_t, const std::vector< size_t > &)> &modifierFunction) |
| void | setCompositionKernelArguments (const KernelId compositionId, const KernelId kernelId, const std::vector< ArgumentId > &argumentIds) |
| template<typename T > | |
| ArgumentId | addArgumentVector (const std::vector< T > &data, const ArgumentAccessType accessType) |
| template<typename T > | |
| ArgumentId | addArgumentVector (std::vector< T > &data, const ArgumentAccessType accessType, const ArgumentMemoryLocation memoryLocation, const bool copyData) |
| template<typename T > | |
| ArgumentId | addArgumentScalar (const T &data) |
| template<typename T > | |
| ArgumentId | addArgumentLocal (const size_t localMemoryElementsCount) |
| void | persistArgument (const ArgumentId id, const bool flag) |
| void | downloadPersistentArgument (const OutputDescriptor &output) const |
| std::vector< ComputationResult > | tuneKernel (const KernelId id) |
| std::vector< ComputationResult > | tuneKernel (const KernelId id, std::unique_ptr< StopCondition > stopCondition) |
| std::vector< ComputationResult > | dryTuneKernel (const KernelId id, const std::string &filePath, const size_t iterations=0) |
| ComputationResult | tuneKernelByStep (const KernelId id, const std::vector< OutputDescriptor > &output) |
| ComputationResult | tuneKernelByStep (const KernelId id, const std::vector< OutputDescriptor > &output, const bool recomputeReference) |
| ComputationResult | runKernel (const KernelId id, const std::vector< ParameterPair > &configuration, const std::vector< OutputDescriptor > &output) |
| void | clearKernelData (const KernelId id, const bool clearConfigurations) |
| void | setKernelProfiling (const bool flag) |
| void | setCompositionKernelProfiling (const KernelId compositionId, const KernelId kernelId, const bool flag) |
| void | setKernelProfilingCounters (const std::vector< std::string > &counterNames) |
| void | setSearchMethod (const SearchMethod method, const std::vector< double > &arguments) |
| void | setPrintingTimeUnit (const TimeUnit unit) |
| void | setInvalidResultPrinting (const bool flag) |
| void | printResult (const KernelId id, std::ostream &outputTarget, const PrintFormat format) const |
| void | printResult (const KernelId id, const std::string &filePath, const PrintFormat format) const |
| ComputationResult | getBestComputationResult (const KernelId id) const |
| std::string | getKernelSource (const KernelId id, const std::vector< ParameterPair > &configuration) const |
| void | setReferenceKernel (const KernelId id, const KernelId referenceId, const std::vector< ParameterPair > &referenceConfiguration, const std::vector< ArgumentId > &validatedArgumentIds) |
| void | setReferenceClass (const KernelId id, std::unique_ptr< ReferenceClass > referenceClass, const std::vector< ArgumentId > &validatedArgumentIds) |
| void | setValidationMode (const ValidationMode mode) |
| void | setValidationMethod (const ValidationMethod method, const double toleranceThreshold) |
| void | setValidationRange (const ArgumentId id, const size_t range) |
| void | setArgumentComparator (const ArgumentId id, const std::function< bool(const void *, const void *)> &comparator) |
| void | setCompilerOptions (const std::string &options) |
| void | setKernelCacheCapacity (const size_t capacity) |
| void | printComputeAPIInfo (std::ostream &outputTarget) const |
| std::vector< PlatformInfo > | getPlatformInfo () const |
| std::vector< DeviceInfo > | getDeviceInfo (const PlatformIndex platform) const |
| DeviceInfo | getCurrentDeviceInfo () const |
| void | setAutomaticGlobalSizeCorrection (const bool flag) |
| void | setGlobalSizeType (const GlobalSizeType type) |
Static Public Member Functions | |
| static void | setLoggingLevel (const LoggingLevel level) |
| static void | setLoggingTarget (std::ostream &outputTarget) |
| static void | setLoggingTarget (const std::string &filePath) |
Class which serves as the main part of public API of KTT framework.
|
explicit |
Constructor, which creates new tuner object for specified platform and device. Tuner uses OpenCL as compute API, all commands are submitted to a single compute queue. Indices for available platforms and devices can be retrieved by calling printComputeAPIInfo() method.
| platform | Index for platform used by created tuner. |
| device | Index for device used by created tuner. |
|
explicit |
Constructor, which creates new tuner object for specified platform, device and compute API. All commands are submitted to a single compute queue. Indices for available platforms and devices can be retrieved by calling printComputeAPIInfo() method. If specified compute API is CUDA, platform index is ignored.
| platform | Index for platform used by created tuner. |
| device | Index for device used by created tuner. |
| computeAPI | Compute API used by created tuner. |
|
explicit |
Constructor, which creates new tuner object for specified platform, device and compute API. Several compute queues are created, based on specified count. Commands to different queues can be submitted by utilizing TuningManipulator. Indices for available platforms and devices can be retrieved by calling printComputeAPIInfo() method. If specified compute API is CUDA, platform index is ignored.
| platform | Index for platform used by created tuner. |
| device | Index for device used by created tuner. |
| computeAPI | Compute API used by created tuner. |
| computeQueueCount | Number of compute queues created inside the tuner. Has to be greater than zero. |
| ktt::Tuner::~Tuner | ( | ) |
Tuner destructor.
|
inline |
Adds new local memory (shared memory in CUDA) argument to tuner. All local memory arguments are read-only and cannot be initialized from host memory. In case of CUDA API usage, local memory arguments cannot be directly set as kernel function arguments. Setting a local memory argument to kernel in CUDA means that corresponding amount of memory will be allocated for kernel to use. In that case, all local memory argument ids should be specified at the end of the vector when calling setKernelArguments() method.
| localMemoryElementsCount | Specifies how many elements of provided data type the argument contains. |
|
inline |
Adds new scalar argument to tuner. All scalar arguments are read-only.
| data | Argument data provided as single scalar value. The data type must be trivially copyable. Bool data type is currently not supported. |
|
inline |
Adds new vector argument to tuner. Makes copy of argument data, so the source data vector remains unaffected by tuner operations. Argument data will be accessed from device memory during its usage by compute API.
| data | Argument data provided in std::vector. Provided data type must be trivially copyable. Bool data type is currently not supported. |
| accessType | Access type of argument specifies whether argument is used for input or output. See ArgumentAccessType for more information. |
|
inline |
Adds new vector argument to tuner. Allows choice for argument memory location and whether argument data is copied to tuner.
| data | Argument data provided in std::vector. Provided data type must be trivially copyable. Bool data type is currently not supported. |
| accessType | Access type of argument specifies whether argument is used for input or output. See ArgumentAccessType for more information. |
| memoryLocation | Memory location of argument specifies whether argument will be accessed from device or host memory during its usage by compute API. See ArgumentMemoryLocation for more information. |
| copyData | Flag which specifies whether the argument is copied inside tuner. If set to false, tuner will store reference of source data vector and will access it directly during kernel launch operations. This results in lower memory overhead, but relies on a user to keep data in source vector valid. |
| KernelId ktt::Tuner::addComposition | ( | const std::string & | compositionName, |
| const std::vector< KernelId > & | kernelIds, | ||
| std::unique_ptr< TuningManipulator > | manipulator | ||
| ) |
Creates a kernel composition using specified kernels. The following methods can be used with kernel compositions and will call the corresponding method for all kernels inside the composition: setKernelArguments(), addParameter() (both versions), addConstraint().
Kernel compositions do not inherit any parameters or constraints from the original kernels. Setting kernel arguments and adding parameters or constraints to kernels inside given composition will not affect the original kernels or other compositions. Tuning manipulator is required in order to launch kernel composition with the tuner. See TuningManipulator for more information.
| compositionName | Name of kernel composition. The name is used during output printing. |
| kernelIds | Ids of kernels which will be included in the composition. |
| manipulator | Tuning manipulator for the composition. |
| void ktt::Tuner::addConstraint | ( | const KernelId | id, |
| const std::vector< std::string > & | parameterNames, | ||
| const std::function< bool(const std::vector< size_t > &)> & | constraintFunction | ||
| ) |
Adds new constraint for specified kernel. Constraints are used to prevent generating of invalid configurations (eg. conflicting parameter values).
| id | Id of kernel for which the constraint will be added. |
| parameterNames | Names of kernel parameters which will be affected by the constraint function. The order of parameter names corresponds to the order of parameter values inside the constraint function vector argument. |
| constraintFunction | Function which returns true if provided combination of parameter values is valid. Returns false otherwise. |
| KernelId ktt::Tuner::addKernel | ( | const std::string & | source, |
| const std::string & | kernelName, | ||
| const DimensionVector & | globalSize, | ||
| const DimensionVector & | localSize | ||
| ) |
Adds new kernel to tuner from source code inside string. Requires specification of kernel name and default global and local thread sizes.
| source | Kernel source code written in corresponding compute API language. |
| kernelName | Name of kernel function inside kernel source code. |
| globalSize | Dimensions for base kernel global size (eg. grid size in CUDA). |
| localSize | Dimensions for base kernel local size (eg. block size in CUDA). |
| KernelId ktt::Tuner::addKernelFromFile | ( | const std::string & | filePath, |
| const std::string & | kernelName, | ||
| const DimensionVector & | globalSize, | ||
| const DimensionVector & | localSize | ||
| ) |
Adds new kernel to tuner from source code inside file. Requires specification of kernel name and default global and local thread sizes.
| filePath | Path to file with kernel source code written in corresponding compute API language. |
| kernelName | Name of kernel function inside kernel source code. |
| globalSize | Dimensions for base kernel global size (eg. grid size in CUDA). |
| localSize | Dimensions for base kernel local size (eg. block size in CUDA). |
| void ktt::Tuner::addParameter | ( | const KernelId | id, |
| const std::string & | parameterName, | ||
| const std::vector< size_t > & | parameterValues | ||
| ) |
Adds new integer parameter for specified kernel, providing parameter name and list of allowed values. When the corresponding kernel is launched, parameters will be added to kernel source code as preprocessor definitions. During the tuning process, tuner will generate configurations for combinations of kernel parameters and their values.
| id | Id of kernel for which the parameter will be added. |
| parameterName | Name of a parameter. Parameter names for single kernel must be unique. |
| parameterValues | Vector of allowed values for the parameter. |
| void ktt::Tuner::addParameterDouble | ( | const KernelId | id, |
| const std::string & | parameterName, | ||
| const std::vector< double > & | parameterValues | ||
| ) |
Adds new floating-point parameter for specified kernel, providing parameter name and list of allowed values. When the corresponding kernel is launched, parameters will be added to kernel source code as preprocessor definitions. During the tuning process, tuner will generate configurations for combinations of kernel parameters and their values.
| id | Id of kernel for which the parameter will be added. |
| parameterName | Name of a parameter. Parameter names for single kernel must be unique. |
| parameterValues | Vector of allowed values for the parameter. |
| void ktt::Tuner::addParameterPack | ( | const KernelId | id, |
| const std::string & | packName, | ||
| const std::vector< std::string > & | parameterNames | ||
| ) |
Adds a pack containing specified kernel parameters. When parameter packs are used, tuning configurations are generated progressively for each pack. Once best configuration is found for a specific pack, next pack is then processed. This method is useful when kernels contain groups of parameters that can be tuned independently. The total number of generated configurations that need to be tested is reduced.
| id | Id of kernel for which the parameter pack will be added. |
| packName | Name of a parameter pack. Parameter pack names for a single kernel must be unique. |
| parameterNames | Names of parameters which will be added to the parameter pack. |
| void ktt::Tuner::clearKernelData | ( | const KernelId | id, |
| const bool | clearConfigurations | ||
| ) |
Resets tuning process and clears tuning results for specified kernel.
| id | Id of kernel whose data will be cleared. |
| clearConfigurations | If true, generated kernel configurations will be cleared as well. Otherwise, they will remain inside tuner. |
| void ktt::Tuner::downloadPersistentArgument | ( | const OutputDescriptor & | output | ) | const |
Downloads specified persistent argument from compute API buffer into specified memory location.
| output | User-provided memory location for persistent kernel argument which should be retrieved. See OutputDescriptor for more information. |
| std::vector< ComputationResult > ktt::Tuner::dryTuneKernel | ( | const KernelId | id, |
| const std::string & | filePath, | ||
| const size_t | iterations = 0 |
||
| ) |
Starts the simulated tuning process for specified kernel (kernel is not tuned, execution times are read from CSV). Creates configuration space based on combinations of provided kernel parameters and constraints. The configurations will be launched in order that depends on specified SearchMethod. This method can be used to test behaviour and performance of newly implemented search methods. Note that no checks are performed whether the tuning data relates to kernel, tuning parameters or hardware. It is up to user to ensure that dryTuneKernel() reads a valid file.
| id | Id of kernel for which the tuning begins. |
| filePath | Path to CSV file with tuning parameters. |
| iterations | Number of iterations performed, 0 = scan whole tuning space. |
| ComputationResult ktt::Tuner::getBestComputationResult | ( | const KernelId | id | ) | const |
Returns the best computation result found for specified kernel. Valid result will be returned only if one of the kernel tuning methods was already called for corresponding kernel.
| id | Id of kernel for which the best result will be returned. |
| DeviceInfo ktt::Tuner::getCurrentDeviceInfo | ( | ) | const |
Retrieves detailed information about device (eg. device name, memory capacity) used by the tuner. See DeviceInfo for more information.
| std::vector< DeviceInfo > ktt::Tuner::getDeviceInfo | ( | const PlatformIndex | platform | ) | const |
Retrieves detailed information about all available devices (eg. device name, memory capacity) on specified platform. See DeviceInfo for more information.
| platform | Index of platform for which the device information will be retrieved. |
| std::string ktt::Tuner::getKernelSource | ( | const KernelId | id, |
| const std::vector< ParameterPair > & | configuration | ||
| ) | const |
Returns kernel source with preprocessor definitions for specified kernel based on provided configuration.
| id | Id of kernel for which the source is returned. |
| configuration | Kernel configuration for which the source will be generated. See ParameterPair for more information. |
| std::vector< PlatformInfo > ktt::Tuner::getPlatformInfo | ( | ) | const |
Retrieves detailed information about all available platforms (eg. platform name, vendor). See PlatformInfo for more information.
| void ktt::Tuner::persistArgument | ( | const ArgumentId | id, |
| const bool | flag | ||
| ) |
Controls whether specified vector argument is persisted inside a compute API buffer or not. Persisted arguments remain inside buffers even after the execution of kernel utilizing these arguments has finished. Persistence of kernel arguments is switched off by default. Persistent arguments can be useful during online tuning and regular kernel running, when kernel output is computed over multiple kernel launches in different configurations. Note that persistent arguments are never utilized by reference kernels.
| id | Id of a vector argument. |
| flag | Specifies whether argument should be persisted or not. If true, specified vector argument is immediately persisted. If false, compute API buffer for specified argument is immediately destroyed. |
| void ktt::Tuner::printComputeAPIInfo | ( | std::ostream & | outputTarget | ) | const |
Prints basic information about available platforms and devices to specified output stream. Also prints indices assigned to them by KTT framework.
| outputTarget | Location where the information will be printed. |
| void ktt::Tuner::printResult | ( | const KernelId | id, |
| std::ostream & | outputTarget, | ||
| const PrintFormat | format | ||
| ) | const |
Prints tuning results for specified kernel to specified output stream. Valid results will be printed only if method tuneKernel() or tuneKernelByStep() was already called for corresponding kernel.
| id | Id of kernel for which the results will be printed. |
| outputTarget | Location where the results will be printed. |
| format | Format in which the results will be printed. See PrintFormat for more information. |
| void ktt::Tuner::printResult | ( | const KernelId | id, |
| const std::string & | filePath, | ||
| const PrintFormat | format | ||
| ) | const |
Prints tuning results for specified kernel to specified file. Valid results will be printed only if method tuneKernel() or tuneKernelByStep() was already called for corresponding kernel.
| id | Id of kernel for which the results will be printed. |
| filePath | Path to file where the results will be printed. |
| format | Format in which the results are printed. See PrintFormat for more information. |
| ComputationResult ktt::Tuner::runKernel | ( | const KernelId | id, |
| const std::vector< ParameterPair > & | configuration, | ||
| const std::vector< OutputDescriptor > & | output | ||
| ) |
Runs specified kernel using provided configuration.
| id | Id of kernel which will be run. |
| configuration | Configuration under which the kernel will be launched. See ParameterPair for more information. |
| output | User-provided memory locations for kernel arguments which should be retrieved. See OutputDescriptor for more information. |
| void ktt::Tuner::setArgumentComparator | ( | const ArgumentId | id, |
| const std::function< bool(const void *, const void *)> & | comparator | ||
| ) |
Sets argument comparator for specified kernel argument. Arguments with custom data type cannot be compared using built-in comparison operators and require user to provide a comparator. Comparator can also be optionally added for arguments with built-in data types.
| id | Id of argument for which the comparator will be set. |
| comparator | Function which receives two elements with data type matching the data type of specified kernel argument and returns true if the elements are equal. Returns false otherwise. |
| void ktt::Tuner::setAutomaticGlobalSizeCorrection | ( | const bool | flag | ) |
Toggles automatic correction for global size, which ensures that global size in each dimension is always a multiple of local size in corresponding dimension. Performs a roundup to the nearest higher multiple. Automatic global size correction is disabled by default.
| flag | If true, automatic global size correction will be enabled. It will be disabled otherwise. |
| void ktt::Tuner::setCompilerOptions | ( | const std::string & | options | ) |
Sets compute API compiler options to specified options. There are no default options for OpenCL back-end. Default option for CUDA back-end is "--gpu-architecture=compute_30".
For list of OpenCL compiler options, see: https://www.khronos.org/registry/OpenCL/sdk/1.2/docs/man/xhtml/clBuildProgram.html For list of CUDA compiler options, see: http://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html#nvcc-command-options
| options | Compute API compiler options. If multiple options are used, they need to be separated by a single space character. |
| void ktt::Tuner::setCompositionKernelArguments | ( | const KernelId | compositionId, |
| const KernelId | kernelId, | ||
| const std::vector< ArgumentId > & | argumentIds | ||
| ) |
Calls setKernelArguments() method for a single kernel inside specified kernel composition. Does not affect standalone kernels or other compositions.
| compositionId | Id of composition which includes the specified kernel. |
| kernelId | Id of kernel inside the composition for which the arguments will be set. |
| argumentIds | Ids of arguments to be used by specified kernel inside the composition. Order of ids must match the order of kernel arguments specified in kernel function. Argument ids for single kernel must be unique. |
| void ktt::Tuner::setCompositionKernelLocalMemoryModifier | ( | const KernelId | compositionId, |
| const KernelId | kernelId, | ||
| const ArgumentId | argumentId, | ||
| const std::vector< std::string > & | parameterNames, | ||
| const std::function< size_t(const size_t, const std::vector< size_t > &)> & | modifierFunction | ||
| ) |
Calls setLocalMemoryModifier() method for a single kernel inside specified kernel composition. Does not affect standalone kernels or other compositions.
| compositionId | Id of composition which includes the specified kernel. |
| kernelId | Id of kernel inside the composition for which the modifier will be set. |
| argumentId | Id of local memory kernel argument which will be affected by the modifier. |
| parameterNames | Names of kernel parameters whose values will be passed into the modifier function. The order of parameter names corresponds to the order of parameter values inside the modifier function vector argument. |
| modifierFunction | Function which receives size of specified local memory argument and values of specified kernel parameters as input and returns modified argument size based on these values. |
| void ktt::Tuner::setCompositionKernelProfiling | ( | const KernelId | compositionId, |
| const KernelId | kernelId, | ||
| const bool | flag | ||
| ) |
Toggles profiling of a specific kernel inside kernel composition. This is useful if only some kernels inside the composition need to be profiled. By default, profiling is enabled for all kernels inside newly added kernel compositions. Note that this method has no effect if kernel profiling is completely disabled. See setKernelProfiling() method for more information.
| compositionId | Id of composition which includes the specified kernel. |
| kernelId | Id of kernel inside the composition for which the profiling flag will be set. |
| flag | If true, kernel profiling is enabled for specified kernel inside the composition. It is disabled otherwise. |
| void ktt::Tuner::setCompositionKernelThreadModifier | ( | const KernelId | compositionId, |
| const KernelId | kernelId, | ||
| const ModifierType | modifierType, | ||
| const ModifierDimension | modifierDimension, | ||
| const std::vector< std::string > & | parameterNames, | ||
| const std::function< size_t(const size_t, const std::vector< size_t > &)> & | modifierFunction | ||
| ) |
Calls setThreadModifier() method for a single kernel inside specified kernel composition. Does not affect standalone kernels or other compositions.
| compositionId | Id of composition which includes the specified kernel. |
| kernelId | Id of kernel inside the composition for which the modifier will be set. |
| modifierType | Type of the thread modifier. See ModifierType for more information. |
| modifierDimension | Dimension which will be affected by the thread modifier. See ModifierDimension for more information. |
| parameterNames | Names of kernel parameters whose values will be passed into the modifier function. The order of parameter names corresponds to the order of parameter values inside the modifier function vector argument. |
| modifierFunction | Function which receives thread size in specified kernel dimension and values of specified kernel parameters as input and returns modified thread size based on these values. |
| void ktt::Tuner::setCompositionKernelThreadModifier | ( | const KernelId | compositionId, |
| const KernelId | kernelId, | ||
| const ModifierType | modifierType, | ||
| const ModifierDimension | modifierDimension, | ||
| const std::string & | parameterName, | ||
| const ModifierAction | modifierAction | ||
| ) |
Calls simplified version of setThreadModifier() method for a single kernel inside specified kernel composition. Does not affect standalone kernels or other compositions.
| compositionId | Id of composition which includes the specified kernel. |
| kernelId | Id of kernel inside the composition for which the modifier will be set. |
| modifierType | Type of the thread modifier. See ModifierType for more information. |
| modifierDimension | Dimension which will be affected by the thread modifier. See ModifierDimension for more information. |
| parameterName | Name of a kernel parameter whose value will be utilized by the thread modifier. |
| modifierAction | Action of the thread modifier. See ModifierAction for more information. |
| void ktt::Tuner::setGlobalSizeType | ( | const GlobalSizeType | type | ) |
Sets global size specification type to specified compute API style. In OpenCL, NDrange size is specified as number of work-items in a work-group multiplied by number of work-groups. In CUDA, grid size is specified as number of blocks. This method makes it possible to use OpenCL style in CUDA and vice versa. Default global size type is the one corresponding to compute API of the tuner.
| type | Global size type which will be set for tuner. See GlobalSizeType for more information. |
| void ktt::Tuner::setInvalidResultPrinting | ( | const bool | flag | ) |
Toggles printing of results from failed kernel runs. Invalid results will be separated from valid results during printing. Printing of invalid results is disabled by default.
| flag | If true, printing of invalid results will be enabled. It will be disabled otherwise. |
| void ktt::Tuner::setKernelArguments | ( | const KernelId | id, |
| const std::vector< ArgumentId > & | argumentIds | ||
| ) |
Sets kernel arguments for specified kernel by providing corresponding argument ids.
| id | Id of kernel for which the arguments will be set. |
| argumentIds | Ids of arguments to be used by specified kernel. Order of ids must match the order of kernel arguments specified in kernel function. Argument ids for single kernel must be unique. |
| void ktt::Tuner::setKernelCacheCapacity | ( | const size_t | capacity | ) |
Sets capacity of kernel cache inside the tuner. The cache contains recently compiled kernels which are prepared to be launched immidiately, eliminating compilation overhead. Using the cache can significantly improve tuner performance during online tuning or iterative kernel running with TuningManipulator. Default cache size is 10.
| capacity | Controls kernel cache capacity. If zero, kernel cache is completely disabled. |
| void ktt::Tuner::setKernelProfiling | ( | const bool | flag | ) |
Toggles profiling of kernel runs inside the tuner. Profiled kernel runs generate profiling counters which can be used by searchers and stop conditions for more accurate performance measurement. Profiling counters can also be retrieved through API and printed into CSV file with tuning results. Note that enabling profiling will result in longer tuning times because profiled kernels have to be launched multiple times with the same configuration in order to collect all profiling counters. Asynchronous kernel launches are currently not supported when kernel profiling is enabled. Kernel profiling is disabled by default.
| flag | If true, kernel profiling is enabled. It is disabled otherwise. |
| void ktt::Tuner::setKernelProfilingCounters | ( | const std::vector< std::string > & | counterNames | ) |
Specifies profiling counters that will be collected during kernel profiling. Note that not all profiling counters are available on all devices.
For the list of CUDA CUPTI profiling counters, see: https://docs.nvidia.com/cuda/cupti/index.html#metrics-reference
| counterNames | Names of counters that will be collected during kernel profiling. |
| void ktt::Tuner::setLocalMemoryModifier | ( | const KernelId | id, |
| const ArgumentId | argumentId, | ||
| const std::vector< std::string > & | parameterNames, | ||
| const std::function< size_t(const size_t, const std::vector< size_t > &)> & | modifierFunction | ||
| ) |
Sets a local memory modifier function for specified kernel. This function receives size of specified local memory argument and values of specified kernel parameters as input and returns modified argument size based on these values. The modifiers are useful in case when kernel parameters affect the size of local memory arguments.
| id | Id of kernel for which the modifier will be set. |
| argumentId | Id of local memory kernel argument which will be affected by the modifier. |
| parameterNames | Names of kernel parameters whose values will be passed into the modifier function. The order of parameter names corresponds to the order of parameter values inside the modifier function vector argument. |
| modifierFunction | Function which receives size of specified local memory argument and values of specified kernel parameters as input and returns modified argument size based on these values. |
|
static |
Sets logging level for tuner. Default logging level is info.
| level | Logging level which will be used by tuner. See LoggingLevel for more information. |
|
static |
Sets the target for info messages logging to specified output stream. Default logging target is std::clog
.
| outputTarget | Location where tuner info messages will be printed. |
|
static |
Sets the target for info messages logging to specified file. Default logging target is std::clog
.
| filePath | Path to file where tuner info messages will printed. |
| void ktt::Tuner::setPrintingTimeUnit | ( | const TimeUnit | unit | ) |
Sets time unit used for printing of results. Default time unit is milliseconds.
| unit | Time unit which will be used for printing of results. See TimeUnit for more information. |
| void ktt::Tuner::setReferenceClass | ( | const KernelId | id, |
| std::unique_ptr< ReferenceClass > | referenceClass, | ||
| const std::vector< ArgumentId > & | validatedArgumentIds | ||
| ) |
Sets reference class for specified kernel. Reference class output will be compared to tuned kernel output in order to ensure correctness of computation.
| id | Id of kernel for which reference class will be set. |
| referenceClass | Reference class which produces reference output for specified kernel. See ReferenceClass for more information. |
| validatedArgumentIds | Ids of kernel arguments which will be validated. The validated arguments must be vector arguments and cannot be read-only. |
| void ktt::Tuner::setReferenceKernel | ( | const KernelId | id, |
| const KernelId | referenceId, | ||
| const std::vector< ParameterPair > & | referenceConfiguration, | ||
| const std::vector< ArgumentId > & | validatedArgumentIds | ||
| ) |
Sets reference kernel for specified kernel. Reference kernel output will be compared to tuned kernel output in order to ensure correctness of computation. Reference kernel uses only single configuration and cannot be composite.
| id | Id of kernel for which reference kernel will be set. |
| referenceId | Id of reference kernel. This can be the same as validated kernel. This can be useful if the kernel has a configuration which is known to produce correct results. |
| referenceConfiguration | Configuration under which the reference kernel will be launched to produce reference output. |
| validatedArgumentIds | Ids of kernel arguments which will be validated. The validated arguments must be vector arguments and cannot be read-only. |
| void ktt::Tuner::setSearchMethod | ( | const SearchMethod | method, |
| const std::vector< double > & | arguments | ||
| ) |
Specifies search method which will be used during kernel tuning. Number of required search arguments depends on the search method. Default search method is full search.
| method | Search method which will be used during kernel tuning. See SearchMethod for more information. |
| arguments | Arguments necessary for specified search method to work. Following arguments are required for corresponding search method, the order of arguments is important:
|
| void ktt::Tuner::setThreadModifier | ( | const KernelId | id, |
| const ModifierType | modifierType, | ||
| const ModifierDimension | modifierDimension, | ||
| const std::vector< std::string > & | parameterNames, | ||
| const std::function< size_t(const size_t, const std::vector< size_t > &)> & | modifierFunction | ||
| ) |
Sets a thread modifier function for specified kernel. This function receives thread size in specified kernel dimension and values of specified kernel parameters as input and returns modified thread size based on these values. The modifiers are useful in case when kernel parameters affect the number of required kernel threads.
| id | Id of kernel for which the modifier will be set. |
| modifierType | Type of the thread modifier. See ModifierType for more information. |
| modifierDimension | Dimension which will be affected by the modifier. See ModifierDimension for more information. |
| parameterNames | Names of kernel parameters whose values will be passed into the modifier function. The order of parameter names corresponds to the order of parameter values inside the modifier function vector argument. |
| modifierFunction | Function which receives thread size in specified kernel dimension and values of specified kernel parameters as input and returns modified thread size based on these values. |
| void ktt::Tuner::setThreadModifier | ( | const KernelId | id, |
| const ModifierType | modifierType, | ||
| const ModifierDimension | modifierDimension, | ||
| const std::string & | parameterName, | ||
| const ModifierAction | modifierAction | ||
| ) |
Sets a thread modifier for specified kernel. This is a simplified version of the thread modifier method which only supports one parameter and limited number of actions, but is easier to use.
| id | Id of kernel for which the modifier will be set. |
| modifierType | Type of the thread modifier. See ModifierType for more information. |
| modifierDimension | Dimension which will be affected by the thread modifier. See ModifierDimension for more information. |
| parameterName | Name of a kernel parameter whose value will be utilized by the thread modifier. |
| modifierAction | Action of the thread modifier. See ModifierAction for more information. |
| void ktt::Tuner::setTuningManipulator | ( | const KernelId | id, |
| std::unique_ptr< TuningManipulator > | manipulator | ||
| ) |
Sets tuning manipulator for specified kernel. Tuning manipulator enables customization of kernel execution. This is useful in several cases, eg. running part of the computation in C++ code, utilizing iterative kernel launches or composite kernels. See TuningManipulator for more information.
| id | Id of kernel for which the tuning manipulator will be set. |
| manipulator | Tuning manipulator for specified kernel. |
| void ktt::Tuner::setTuningManipulatorSynchronization | ( | const KernelId | id, |
| const bool | flag | ||
| ) |
Controls whether framework performs implicit device synchronization after launchComputation() method inside tuning manipulator has finished. Performing the synchronization is necessary for obtaining correct computation duration. Turning it off may increase performance during regular computation after the tuning has concluded. Synchronization is turned on by default.
| id | Id of kernel for which the tuning manipulator synchronization flag will be set. |
| flag | If true, tuning manipulator synchronization will be turned on for specified kernel or kernel composition. It will be turned off otherwise. |
| void ktt::Tuner::setValidationMethod | ( | const ValidationMethod | method, |
| const double | toleranceThreshold | ||
| ) |
Sets validation method and tolerance threshold for floating-point argument validation. Default validation method is side by side comparison. Default tolerance threshold is 1e-4.
| method | Validation method which will be used for floating-point argument validation. See ValidationMethod for more information. |
| toleranceThreshold | Output validation threshold. If difference between tuned kernel output and reference output is within tolerance threshold, the tuned kernel output will be considered correct. |
| void ktt::Tuner::setValidationMode | ( | const ValidationMode | mode | ) |
Sets modes under which kernel output validation is enabled. By default, output validation is enabled only during kernel tuning.
| mode | Bitfield of modes under which kernel output validation is enabled. See ValidationMode for more information. |
| void ktt::Tuner::setValidationRange | ( | const ArgumentId | id, |
| const size_t | range | ||
| ) |
Sets validation range for specified argument to specified validation range. Only elements within validation range, starting with the first element, will be validated. All elements are validated by default.
| id | Id of argument for which the validation range will be set. |
| range | Range inside which the argument elements will be validated, starting from the first element. |
| std::vector< ComputationResult > ktt::Tuner::tuneKernel | ( | const KernelId | id | ) |
Starts the tuning process for specified kernel. Creates configuration space based on combinations of provided kernel parameters and constraints. The configurations will be launched in order that depends on specified SearchMethod. Tuning will end when all configurations are explored.
| id | Id of kernel for which the tuning will start. |
| std::vector< ComputationResult > ktt::Tuner::tuneKernel | ( | const KernelId | id, |
| std::unique_ptr< StopCondition > | stopCondition | ||
| ) |
Starts the tuning process for specified kernel. Creates configuration space based on combinations of provided kernel parameters and constraints. The configurations will be launched in order that depends on specified SearchMethod. Tuning will end either when all configurations are explored or when specified stop condition is met.
| id | Id of kernel for which the tuning will start. |
| stopCondition | Stop condition which decides whether to continue the tuning process. See StopCondition for more information. |
| ComputationResult ktt::Tuner::tuneKernelByStep | ( | const KernelId | id, |
| const std::vector< OutputDescriptor > & | output | ||
| ) |
Performs one step of the tuning process for specified kernel. When this method is called inside tuner for the first time, it creates configuration space based on combinations of provided kernel parameters and constraints. Each time this method is called, it launches single kernel configuration. If all configurations were already tested, runs kernel using the best configuration. Output data can be retrieved by providing output descriptors. Always performs recomputation of reference output.
| id | Id of kernel for which the tuning by step will start. |
| output | User-provided memory locations for kernel arguments which should be retrieved. See OutputDescriptor for more information. |
| ComputationResult ktt::Tuner::tuneKernelByStep | ( | const KernelId | id, |
| const std::vector< OutputDescriptor > & | output, | ||
| const bool | recomputeReference | ||
| ) |
Performs one step of the tuning process for specified kernel. When this method is called inside tuner for the first time, it creates configuration space based on combinations of provided kernel parameters and constraints. Each time this method is called, it launches single kernel configuration. If all configurations were already tested, runs kernel using the best configuration. Output data can be retrieved by providing output descriptors. Allows control over recomputation of reference output.
| id | Id of kernel for which the tuning by step will start. |
| output | User-provided memory locations for kernel arguments which should be retrieved. See OutputDescriptor for more information. |
| recomputeReference | Flag which controls whether recomputation of reference output should be performed or not. Useful if kernel data between individual method invocations sometimes change. |


This section gives a general overview of the available XSI constructs.
Subtopics:
CONSTRAINT_ATTRIBUTES
DEFCLASS
DEFFACTS
DEFFUNCTION
DEFGENERIC/DEFMETHOD
DEFGLOBAL
DEFINSTANCES
DEFMESSAGE-HANDLER
DEFMODULE
DEFRULE
DEFTEMPLATE


GeoMesa GeoServer Plugins¶
A straightforward way to render, manipulate, and manage data stored in GeoMesa data stores is to use GeoServer, an open source server for sharing geospatial data. This chapter describes how to work with the GeoMesa GeoServer plugins.
Installation¶
Instructions for installing the GeoMesa plugins in GeoServer are available at Installing the GeoMesa GeoServer Plugins.
Go to your GeoServer installation at http://<hostname>:8080/geoserver
.
For new installations of GeoServer, the default username is admin
and
password is geoserver
, but these may be different at your own installation.
Creating a Data Store¶
From the main GeoServer page, create a new store by either clicking “Add stores” in the middle of the Welcome page, or anywhere in the interface by clicking “Data > Stores” in the left-hand menu and then clicking “Add new Store”.
If you have properly installed the GeoMesa GeoServer plugins as described in Installing the GeoMesa GeoServer Plugins, the plugins with the names specified below should be included in the list under Vector Data Sources. If you do not see this for a particular plugin, check that you unpacked the plugin JARs into in the right directory and restart GeoServer.
Accumulo Data Store¶
On the “Add Store” page, select “Accumulo (GeoMesa)”. The Accumulo Data Store takes several parameters:
| Parameter | Description |
|---|---|
| instanceId * | The instance ID of the Accumulo installation |
| zookeepers * | A comma separated list of zookeeper servers (e.g. “zoo1,zoo2,zoo3” or “localhost:2181”) |
| user * | Accumulo username |
| Password * | Accumulo password |
| tableName * | The name of the GeoMesa catalog table |
| auths | Comma-delimited superset of authorizations that will be used for queries via Accumulo. |
| visibilities | Accumulo visibilities to apply to all written data |
| queryTimeout | The max time (in sec) a query will be allowed to run before being killed |
| queryThreads | The number of threads to use per query |
| recordThreads | The number of threads to use for record retrieval |
| writeThreads | The number of threads to use for writing records |
| collectStats | Toggle collection of statistics |
| caching | Toggle caching of results |
The required parameters are marked with an asterisk. Click “Save”, and GeoServer will search your Accumulo table for any GeoMesa-managed feature types.
Kafka Data Store¶
On the “Add Store” page, select “Kafka (GeoMesa)”. The Kafka Data Store takes several parameters.
| Parameter | Type | Description |
|---|---|---|
| brokers * | String | Comma-separated list of Kafka brokers |
| zookeepers * | String | Comma-separated list of Zookeeper servers |
| zkPath | String | Path to GeoMesa Kafka data in Zookeeper |
| namespace | String | Namespace |
| partitions | Integer | Number of partitions to use in Kafka topics |
| replication | Integer | Replication factor to use in Kafka topics |
| isProducer | Boolean | Indicates whether the Kafka Data Store is a producer |
| expirationPeriod | Long | Feature will be “auto-dropped” (expired) after this delay in milliseconds. Leave black or use -1 to not drop features. |
| cleanUpCache | Boolean | If true, run a thread to clean up the live feature cache every second if set to true. False by default. |
The required parameters are marked with an asterisk. Click “Save”, and GeoServer will search Kafka for any GeoMesa-managed feature types.
HBase Data Store¶
On the “Add Store” page, select “HBase (GeoMesa)”. The HBase data store takes two parameters:
- bigtable.table.name - the name of the HBase table that stores feature type data
- namespace - the namespace URI for the data store (optional)
Other configuration information is taken from the HBase site.xml
file (see
For HBase).
Click “Save”, and GeoServer will search HBase for any GeoMesa-managed feature types.
Cassandra Data Store¶
On the “Add Store” page, select “Cassandra (GeoMesa)” as shown below.
In the following page, enter the name and description of the data store, the contact point (HOST:PORT), and the keyspace. Click “Save”, and GeoServer will search Cassandra for any GeoMesa-managed feature types in that keyspace.
Publish a GeoMesa Layer¶
After a GeoMesa data store is successfully created, GeoServer will present a list of feature types registered in that data store. Click “Publish” next to the name of a feature type to create a layer of the data in GeoMesa of that type.
You will be taken to the Edit Layer screen. To render your layer, you must first set values for the bounding boxes in the “Data” pane. In many cases, you can click on the “Compute from native bounds” link to compute these values from the data.
Click on the “Save” button when you are done.
Preview a Layer¶
Click on the “Layer Preview” link in the left-hand menu. Once you see your layer, click on the “OpenLayers” link, which will open a new tab. If you have ingested data into GeoMesa, it will be displayed here.
If the data you have ingested is a set of latitude/longitude points, click on one of the points in the display (rendered by default as red squares), and GeoServer will report detailed records stored in the GeoMesa store in the region underneath the map area.
Click on the “Toggle options toolbar” icon in the upper-left corner of the preview window. The right-hand side of the screen will include a “Filter” text box. Enter a search query on the attributes of the feature type of the data you have ingested, and press on the “play” icon. The display will now show only those points matching your filter criterion.
This is a CQL filter, which can be constructed in various ways to query data. You can find more information about CQL from GeoServer’s CQL tutorial.
Note
If you enabled the time dimension for a layer, such as instructed in the GeoMesa Accumulo Quick Start,
then you will need to specify a TIME parameter in the URL of the form:
&TIME=2014-01-01T00:00:00.000Z/2014-01-31T23:59:59.999Z
That tells GeoServer to display the records for the entire month of January 2014. GeoServer will add an implicit
time filter if you do not specify one, which may cause unexpected results. This TIME parameter is distinct from the
CQL_FILTER parameter and specifying a CQL time filter without the TIME parameter may create an empty intersection
with the implicit time filter. You can find more information about the TIME parameter from GeoServer’s documentation.
Analysis with WPS¶
As described by the Open Geospatial Consortium’s Web Map Service page,
The OpenGIS® Web Map Service Interface Standard (WMS) provides a simple HTTP interface for requesting geo-registered map images from one or more distributed geospatial databases. A WMS request defines the geographic layer(s) and area of interest to be processed. The response to the request is one or more geo-registered map images (returned as JPEG, PNG, etc) that can be displayed in a browser application. The interface also supports the ability to specify whether the returned images should be transparent so that layers from multiple servers can be combined or not.
A tool like GeoServer (once its WPS plugin has been installed) uses WPS to retrieve data from GeoMesa. WPS processes can be chained, letting you use additional WPS requests to build on the results of earlier ones.
Configuration¶
WMS Plugin¶
Depending on your hardware, it may be important to set the limits for your WMS plugin to be higher or disable them completely by clicking “WMS” under “Services” on the left side of the admin page of GeoServer. Check with your server administrator to determine the correct settings. For massive queries, the standard 60 second timeout may be too short.
Logging Explain Query Planning¶
The GeoMesa Accumulo data store can explain its plan for executing queries,
as described in Explaining: Query Plans. To enable the logging of explain query
planning in GeoServer, add the following to the
$GEOSERVER_DATA_DIR/logs/DEFAULT_LOGGING.properties
file:
log4j.category.org.locationtech.geomesa.index.utils.Explainer=TRACE
If you are not sure of the location of your GeoServer data directory, it is printed out when you start GeoServer:
----------------------------------
- GEOSERVER_DATA_DIR: /path/to/geoserver-data-dir
----------------------------------
Monitoring GeoMesa DataStores¶
GeoMesa DataStores can log query metrics as JSON via log4j. To use this, there are two steps:
First, GeoServer logging needs to log TRACE level messages in the org.locationtech.geomesa.utils.monitoring
package.
To enable that logging, edit the GeoServer logging
file (e.g. $GEOSERVER_DATA_DIR/logs/DEFAULT_LOGGING.properties
) and add entries like:
log4j.appender.metrics=org.apache.log4j.FileAppender
log4j.appender.metrics.File=metrics.log
log4j.appender.metrics.layout=org.apache.log4j.PatternLayout
log4j.appender.metrics.layout.ConversionPattern=%m%n
log4j.category.org.locationtech.geomesa.utils.monitoring=TRACE, metrics
Second as a DataStore is registered in GeoServer, the collectQueryStats box should be ticked for the store.
GeoMesa GeoServer Community Module¶
The GeoMesa community module adds support for raster imagery to GeoServer. The community module requires the Accumulo GeoServer plugin to be installed first.
The community module can be downloaded from OpenGeo, or can be built from source.
Once obtained, the community module can be installed by copying geomesa-gs-<version>.jar
into
the GeoServer lib
directory.


ZwWdP 25.01.11
|
ZEIT |
INTERPRET |
TITEL |
|
20 h |
Beady Eye |
The Roller |
|
|
Aim |
Cold Water Music |
|
|
Tahiti 80 |
Want Some? |
|
|
Orwell |
Happy Where You Are |
|
|
Orwell |
Always |
|
|
Jim Kroft |
Memoirs From The Afterlife |
|
|
The Whitest Boy Alive |
Keep A Secret |
|
|
David Bowie |
Speed Of Life |
|
|
The Mummers |
Fade Away |
|
|
Todd Rundgren |
Hello It's Me |
|
|
Iron & Wine |
Tree By The River |
|
|
Colin Blunstone |
What Becomes Of The Brokenhearted |
|
|
Duran Duran |
The Chauffeur |
|
|
Doctor Rockit |
Café de Flore |
|
21 h |
Aaron Beaumont |
Julia |
|
|
Paul Williams |
She's Too Good To Me |
|
|
Delay Trees |
Light Pollution |
|
|
World Party |
#9 Dream |
|
|
Brian |
Right Through Tuesday |
|
|
Pow! Pow! |
The Beach |
|
|
Warm Morning |
Homeward Bound |
|
|
Harry J Allstars |
My Chérie Amour |
|
|
Colin Blunstone |
Caroline Goodbye |
|
|
The Zombies |
Beechwood Park |
|
|
Prefab Sprout |
Radio Love |
|
|
Brasstronaut |
Insects |
|
|
Al Stewart |
Year Of The Cat |
|
22 h |
Patti Moon |
Painting Horses |
|
|
The Silver Seas |
Another Bad Night's Sleep (Blue Version) |
|
|
The Silver Seas |
What's The Drawback (Blue Version) |
|
|
Betty Chung |
Bang Bang |
|
|
Cal Tjader |
Walk On By |
|
|
The Zombies |
Goin' Out Of My Head |
|
|
Brian Protheroe |
Pinball |
|
|
The Phoenix Foundation |
The Golden Ship |
|
|
10 cc |
Feel The Benefit |
|
|
Saint Etienne |
Dream Lover |
|
|
Beastie Boys & Cibo Matto |
Start! |
|
|
Malkovic |
Chenille |
|
|
ABC |
Theme From Mantrap |
|
|
Isaac Hayes |
Early Sunday Morning |


Universal Hot Stoppers- By
Zakery Clarke
for
Hello Internet
Production:
Bank Account: $5.00
Make Hot Stopper
Inventory: 0 hot stoppers
Raise Price
Price: $0.10
Lower Price
Plastic: 0 lbs
Buy Plastic: $5
Store:
Buy Auto-Molder: $10
Youtube Ad $50
Buy Plastic Factory: $100
Reddit Ad: $100
Create a Brand Mascot: $300
Buy Starbucks Endorsement: $1,000
Buy Nuke: $10,000
Buy Country: $20,000
Buy World: $30,000
Colonize Mars: $50,000
Stats:
Demand: 30%
Time:
Auto-Molders: 0
Plastic Factories: 0


Livingston could look to add to squad as injury list piles up
Boss Gary Holt joked that he may have to put his boots on as the Lions deal with a lengthy injury list.
by Callum Carson, https://www.dailyrecord.co.uk/authors/callum-carson/Gary Holt joked that he might have to come out of retirement to help ease his side’s injury woes.
Skipper Alan Lithgow is set to miss several weeks following surgery to remove his appendix, and joins Nicky Devlin and Cece Pepe on the injury list.
Lithgow (31) missed the defeat to Rangers and could struggle to feature again before the winter break, while Frenchman Pepe picked up a calf injury in a recent reserves game.
Devlin’s season could be in doubt after he damaged knee ligaments in last month’s draw with Hearts.
Chris Erskine and Lee Miller have also missed time recently, while Lyndon Dykes and Scott Pittman have only just returned to first team action.
Holt said: “Bringing someone in is something we’re looking at, but are they going to be up to speed with us having so many games in quick succession before the winter break?
“We have to have a look at what’s out there because we’re right down to the bare bones just now. I might even have to get my boots back on.
“Alan is going to be a big miss and I’m not sure how long he’ll be out for, but that’s part of football and it’s something we have to deal with.”
He added: “Our injuries are affecting us. Even with Pitts and Lyndon, they’re still playing catch up on the fitness side of things so the break is ideal.”


Jennifer He
Project Portfolio
Jennifer is a master student of Computer Science & Engineering at UC San Diego, where she also had her bachelor degree of Chemical engineering. She previously served as lab assistant Undergraduate Research Assistant in Professor Sungho Jin's Research Group, Department of Mechanical and Aerospace Engineering, UC San Diego.
Projects
- Study Group Website: team work to finish a website to serve the students to form a study group for one course with information of content, location and time posted online. This project was written by html, xml, and JavaScript on platform of Meteor, with MongoDB for database.
- Find Free Food: team work to finish a website to serve the students to find free stuff or food on campus. This project was written by html, xml, and JavaScript and python.
- Extended release of paclitaxel and sirolimus from bare-metal
stent surface by nanotexturing and deformation. This is a four-weeks project to check the result of the drug release of paclitaxel and sirolimus from bare-metal stent surface.


You've selected the Run/Bike activity. In order to verify that you're actually working out, we're going to periodically ping your phone's GPS during your runs. This allows us to ensure you're actually going the distance and earning your payouts!
Accept & continue
Go back
ForcedFit
Get paid to get fit
How much do you want to earn per workout?
$10
$20
$50
$100
How many workouts will you do per week?
3
4
5
6
7
Continue to payment
How many weeks of workouts would you like to fund? ($350/week)


@@include("../blocks/modules/header/header.html")
@@include("../blocks/banner/banner.html")
@@include("../blocks/textBlock/textBlock.html")
@@include("../blocks/services/services.html")
@@include("../blocks/posters/posters.html")
@@include("../blocks/contacts/contacts.html")
@@include("../blocks/modules/footer/footer.html")


I attend Northview High School, and I am incredibly passionate about Computer Science.
Check out some recent projects:


LOGIN
JOIN
CART(0)
MY PAGE
LIVE CHAT
BEST
CATEGORY
LIFE
HELP
REVIEW
QUESTION
THE SHARE.LeatherPT
Price
$199.99
Reserves
1.99
COLOR
CHOOSE COLOR
BLACK
BURGUNDY
SIZE
CHOOSE SIZE
S
M
QUATITY
1
2
3


American Migration
Hover over a city to see where people moved, according to
data
from the Census Bureau's 2011-2015 American Community Survey.


Click on this box to start test
The sound is now playing and will gradually increase in volume.
Click on this box when you hear a sound.
Click here to pause
or terminate the survey.


PPSmart's Portfolio
Web Application made with React, Django, GraphQL, and PostgreSQL
{% for job in jobs %}
{{ job.summary }}
{% endfor %}
{{ job.title }}
{{ job.description }}


Make a Webservice |
Make a Webservice |
The JavaScript World |
URL RegEx |
HTTPie |
Web Engineering |
How can I sketch an application? |
Improvements for my University's Website |
Custom 404 error pages |
Search Engine Autodiscovery |
Password Changing Services |


Google Tag Assistant is a Chrome Extension that helps you validate the tracking code on your website and troubleshoot common problems. It's an ideal tool for debugging and testing your analytics.js implementations locally and ensuring everything is correct before deploying your code to production.
Tag Assistant works by letting you record a typical user flow. It keeps track of all the hits you send, checks them for any problems, and gives you a full report of the interactions. If it detects any issues or potential improvements, it will let you know.
To see how Tag Assistant works, check out the video below. In it Philip Walton, Developer Programs Engineer on the Google Analytics team, demonstrates how you can use Tag Assistant to catch errors and check the validity of advanced tracking implementations such as cross-domain tracking.
To learn more about Tag Assistant and using Tag Assistant Recordings, you can read about them in the Google Analytics Help Center:


Helion Openstack IaaS Simple Compute
Copy of CSL HP Helion OpenStack v2 - Compute
Aug 3, 2015 11:59:55 PM
consumer
Server
Deployed Services |
||
|---|---|---|
| Disk (GB) |
20
|
|
| Fixed IP Addresses |
<IP_ADDRESS>
|
|
| Flavor Name |
m1.small
|
|
| Floating IP Address |
NONE
|
|
| Floating IP Pool |
ext-net
|
|
| Image Name |
CentOS-6.5
|
|
| Keypair |
AJ
|
|
| Memory (MB) |
2048
|
|
| Network Name |
default-net
|
|
| Number Of CPUs |
1
|
|
| Security Group |
default
|
|
| Server ID |
237ddd68-3497-4489-9b3c-3377ea375299
|
|
| Server Name |
VMec35bc
|
|
| Status |
ACTIVE
|
|
| Tenant Name |
csa_demo
|
Cloud Raxak Security & Compliance Services
Compliance checking in progress |
||
|---|---|---|
| Successfully passed rule(s): | ||
| Failed rule(s): | ||
| Rule(s) needing manual: | ||
| Console Log |
Click to view
+
-
|
|