Stop tracing object allocations.
Note that if ::trace_object_allocations_start is called n-times, then tracing will stop after calling ::trace_object_allocations_stop n-times.
Returns the number of online processors.
The result is intended as the number of processes to use all available processors.
This method is implemented using:
sched_getaffinity(): Linux
sysconf(_SC_NPROCESSORS_ONLN): GNU/Linux, NetBSD, FreeBSD, OpenBSD, DragonFly BSD, OpenIndiana, Mac OS X, AIX
Example:
require 'etc' p Etc.nprocessors #=> 4
The result might be smaller number than physical cpus especially when ruby process is bound to specific cpus. This is intended for getting better parallel processing.
Example: (Linux)
linux$ taskset 0x3 ./ruby -retc -e "p Etc.nprocessors" #=> 2
Gets the scheduling priority for specified process, process group, or user. kind indicates the kind of entity to find: one of Process::PRIO_PGRP, Process::PRIO_USER, or Process::PRIO_PROCESS. integer is an id indicating the particular process, process group, or user (an id of 0 means current). Lower priorities are more favorable for scheduling. Not available on all platforms.
Process.getpriority(Process::PRIO_USER, 0) #=> 19 Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19
See Process#getpriority.
Process.setpriority(Process::PRIO_USER, 0, 19) #=> 0 Process.setpriority(Process::PRIO_PROCESS, 0, 19) #=> 0 Process.getpriority(Process::PRIO_USER, 0) #=> 19 Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19
Initializes the supplemental group access list by reading the system group database and using all groups of which the given user is a member. The group with the specified gid is also added to the list. Returns the resulting Array of the gids of all the groups in the supplementary group access list. Not available on all platforms.
Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27] Process.initgroups( "mgranger", 30 ) #=> [30, 6, 10, 11] Process.groups #=> [30, 6, 10, 11]
Get an Array of the gids of groups in the supplemental group access list for this process.
Process.groups #=> [27, 6, 10, 11]
Set the supplemental group access list to the given Array of group IDs.
Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27] Process.groups = [27, 6, 10, 11] #=> [27, 6, 10, 11] Process.groups #=> [27, 6, 10, 11]
Returns the maximum number of gids allowed in the supplemental group access list.
Process.maxgroups #=> 32
Sets the maximum number of gids allowed in the supplemental group access list.
Returns the cross product of this vector with the others.
Vector[1, 0, 0].cross_product Vector[0, 1, 0] => Vector[0, 0, 1]
It is generalized to other dimensions to return a vector perpendicular to the arguments.
Vector[1, 2].cross_product # => Vector[-2, 1] Vector[1, 0, 0, 0].cross_product( Vector[0, 1, 0, 0], Vector[0, 0, 1, 0] ) #=> Vector[0, 0, 0, 1]
Outputs the results from the profiler.
See Profiler__ for more information.
Returns an array of all combinations of elements from all arrays.
The length of the returned array is the product of the length of self and the argument arrays.
If given a block, product will yield all combinations and return self instead.
[1,2,3].product([4,5]) #=> [[1,4],[1,5],[2,4],[2,5],[3,4],[3,5]] [1,2].product([1,2]) #=> [[1,1],[1,2],[2,1],[2,2]] [1,2].product([3,4],[5,6]) #=> [[1,3,5],[1,3,6],[1,4,5],[1,4,6], # [2,3,5],[2,3,6],[2,4,5],[2,4,6]] [1,2].product() #=> [[1],[2]] [1,2].product([]) #=> []
With no arguments, sets the default visibility for subsequently defined methods to protected. With arguments, sets the named methods to have protected visibility. String arguments are converted to symbols.
If a method has protected visibility, it is callable only where self of the context is the same as the method. (method definition or instance_eval). This behavior is different from Java’s protected method. Usually private should be used.
Note that a protected method is slow because it can’t use inline cache.
To show a private method on RDoc, use :doc: instead of this.
Runs the early binding method to get property. The 1st argument specifies dispatch ID, the 2nd argument specifies the array of arguments, the 3rd argument specifies the array of the type of arguments.
excel = WIN32OLE.new('Excel.Application') puts excel._getproperty(558, [], []) # same effect as puts excel.visible
Runs the early binding method to set property. The 1st argument specifies dispatch ID, the 2nd argument specifies the array of arguments, the 3rd argument specifies the array of the type of arguments.
excel = WIN32OLE.new('Excel.Application') excel._setproperty(558, [true], [WIN32OLE::VARIANT::VT_BOOL]) # same effect as excel.visible = true
Sets property of OLE object. When you want to set property with argument, you can use this method.
excel = WIN32OLE.new('Excel.Application') excel.Visible = true book = excel.workbooks.add sheet = book.worksheets(1) sheet.setproperty('Cells', 1, 2, 10) # => The B1 cell value is 10.
Returns array of ProgID.
Returns ProgID if it exists. If not found, then returns nil.
tobj = WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Application') puts tobj.progid # => Excel.Application.9
Returns a time returned by POSIX clock_gettime() function.
p Process.clock_gettime(Process::CLOCK_MONOTONIC) #=> 896053.968060096
clock_id specifies a kind of clock. It is specified as a constant which begins with Process::CLOCK_ such as Process::CLOCK_REALTIME and Process::CLOCK_MONOTONIC.
The supported constants depends on OS and version. Ruby provides following types of clock_id if available.
CLOCK_REALTIME
SUSv2 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 2.1, macOS 10.12
CLOCK_MONOTONIC
SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 3.4, macOS 10.12
CLOCK_PROCESS_CPUTIME_ID
SUSv3 to 4, Linux 2.5.63, OpenBSD 5.4, macOS 10.12
CLOCK_THREAD_CPUTIME_ID
SUSv3 to 4, Linux 2.5.63, FreeBSD 7.1, OpenBSD 5.4, macOS 10.12
CLOCK_VIRTUAL
FreeBSD 3.0, OpenBSD 2.1
CLOCK_PROF
FreeBSD 3.0, OpenBSD 2.1
CLOCK_REALTIME_FAST
FreeBSD 8.1
CLOCK_REALTIME_PRECISE
FreeBSD 8.1
CLOCK_REALTIME_COARSE
Linux 2.6.32
CLOCK_REALTIME_ALARM
Linux 3.0
CLOCK_MONOTONIC_FAST
FreeBSD 8.1
CLOCK_MONOTONIC_PRECISE
FreeBSD 8.1
CLOCK_MONOTONIC_COARSE
Linux 2.6.32
CLOCK_MONOTONIC_RAW
Linux 2.6.28, macOS 10.12
CLOCK_MONOTONIC_RAW_APPROX
macOS 10.12
CLOCK_BOOTTIME
Linux 2.6.39
CLOCK_BOOTTIME_ALARM
Linux 3.0
CLOCK_UPTIME
FreeBSD 7.0, OpenBSD 5.5
CLOCK_UPTIME_FAST
FreeBSD 8.1
CLOCK_UPTIME_RAW
macOS 10.12
CLOCK_UPTIME_RAW_APPROX
macOS 10.12
CLOCK_UPTIME_PRECISE
FreeBSD 8.1
CLOCK_SECOND
FreeBSD 8.1
Note that SUS stands for Single Unix Specification. SUS contains POSIX and clock_gettime is defined in the POSIX part. SUS defines CLOCK_REALTIME mandatory but CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID and CLOCK_THREAD_CPUTIME_ID are optional.
Also, several symbols are accepted as clock_id. There are emulations for clock_gettime().
For example, Process::CLOCK_REALTIME is defined as :GETTIMEOFDAY_BASED_CLOCK_REALTIME when clock_gettime() is not available.
Emulations for CLOCK_REALTIME:
Use gettimeofday() defined by SUS. (SUSv4 obsoleted it, though.) The resolution is 1 microsecond.
Use time() defined by ISO C. The resolution is 1 second.
Emulations for CLOCK_MONOTONIC:
Use mach_absolute_time(), available on Darwin. The resolution is CPU dependent.
Use the result value of times() defined by POSIX. POSIX defines it as “times() shall return the elapsed real time, in clock ticks, since an arbitrary point in the past (for example, system start-up time)”. For example, GNU/Linux returns a value based on jiffies and it is monotonic. However, 4.4BSD uses gettimeofday() and it is not monotonic. (FreeBSD uses clock_gettime(CLOCK_MONOTONIC) instead, though.) The resolution is the clock tick. “getconf CLK_TCK” command shows the clock ticks per second. (The clock ticks per second is defined by HZ macro in older systems.) If it is 100 and clock_t is 32 bits integer type, the resolution is 10 millisecond and cannot represent over 497 days.
Emulations for CLOCK_PROCESS_CPUTIME_ID:
Use getrusage() defined by SUS. getrusage() is used with RUSAGE_SELF to obtain the time only for the calling process (excluding the time for child processes). The result is addition of user time (ru_utime) and system time (ru_stime). The resolution is 1 microsecond.
Use times() defined by POSIX. The result is addition of user time (tms_utime) and system time (tms_stime). tms_cutime and tms_cstime are ignored to exclude the time for child processes. The resolution is the clock tick. “getconf CLK_TCK” command shows the clock ticks per second. (The clock ticks per second is defined by HZ macro in older systems.) If it is 100, the resolution is 10 millisecond.
Use clock() defined by ISO C. The resolution is 1/CLOCKS_PER_SEC. CLOCKS_PER_SEC is the C-level macro defined by time.h. SUS defines CLOCKS_PER_SEC is 1000000. Non-Unix systems may define it a different value, though. If CLOCKS_PER_SEC is 1000000 as SUS, the resolution is 1 microsecond. If CLOCKS_PER_SEC is 1000000 and clock_t is 32 bits integer type, it cannot represent over 72 minutes.
If the given clock_id is not supported, Errno::EINVAL is raised.
unit specifies a type of the return value.
number of seconds as a float (default)
number of milliseconds as a float
number of microseconds as a float
number of seconds as an integer
number of milliseconds as an integer
number of microseconds as an integer
number of nanoseconds as an integer
The underlying function, clock_gettime(), returns a number of nanoseconds. Float object (IEEE 754 double) is not enough to represent the return value for CLOCK_REALTIME. If the exact nanoseconds value is required, use :nanoseconds as the unit.
The origin (zero) of the returned value varies. For example, system start up time, process start up time, the Epoch, etc.
The origin in CLOCK_REALTIME is defined as the Epoch (1970-01-01 00:00:00 UTC). But some systems count leap seconds and others doesn’t. So the result can be interpreted differently across systems. Time.now is recommended over CLOCK_REALTIME.
Returns the time resolution returned by POSIX clock_getres() function.
clock_id specifies a kind of clock. See the document of Process.clock_gettime for details.
clock_id can be a symbol as Process.clock_gettime. However the result may not be accurate. For example, +Process.clock_getres(:GETTIMEOFDAY_BASED_CLOCK_REALTIME)+ returns 1.0e-06 which means 1 microsecond, but actual resolution can be more coarse.
If the given clock_id is not supported, Errno::EINVAL is raised.
unit specifies a type of the return value. Process.clock_getres accepts unit as Process.clock_gettime. The default value, :float_second, is also same as Process.clock_gettime.
Process.clock_getres also accepts :hertz as unit. :hertz means a the reciprocal of :float_second.
:hertz can be used to obtain the exact value of the clock ticks per second for times() function and CLOCKS_PER_SEC for clock() function.
+Process.clock_getres(:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)+ returns the clock ticks per second.
+Process.clock_getres(:CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)+ returns CLOCKS_PER_SEC.
p Process.clock_getres(Process::CLOCK_MONOTONIC) #=> 1.0e-09
Creates an HTTP proxy class which behaves like Net::HTTP, but performs all access via the specified proxy.
This class is obsolete. You may pass these same parameters directly to Net::HTTP.new. See Net::HTTP.new for details of the arguments.
True if requests for this connection will be proxied
Sends a PROPPATCH request to the path and gets a response, as an HTTPResponse object.
Sends a PROPFIND request to the path and gets a response, as an HTTPResponse object.