File=module1-architecture.htm;
updated 5/13/2013
Figures shown in these notes
are from Oracle®
Database Concepts 11g Release 2
Objectives
These notes introduce the Oracle server
architecture. The architecture includes physical
components, memory components, processes, and logical structures.
Primary Architecture
Components
The figure shown above details the Oracle
architecture.
Oracle server: An
Oracle server includes an Oracle Instance and an Oracle database.
·
An
Oracle database includes several different types of files: datafiles, control files, redo log files and
archive redo log files. The Oracle
server also accesses parameter files and password files.
·
This
set of files has several purposes.
o
One is
to enable system users to process SQL statements.
o
Another
is to improve system performance.
o
Still
another is to ensure the database can be recovered if there is a
software/hardware failure.
·
The
database server must manage large amounts of data in a multi-user
environment.
·
The
server must manage concurrent access to the same data.
·
The
server must deliver high performance.
This generally means fast response times.
Oracle instance: An
Oracle Instance consists of two
different sets of components:
·
The first
component set is the set of background processes (PMON, SMON, RECO, DBW0,
LGWR, CKPT, D000 and others).
o
These
will be covered later in detail each background process is a computer
program.
o
These
processes perform input/output and monitor other Oracle processes to provide
good performance and database reliability.
·
The
second component set includes the memory structures that comprise the Oracle
instance.
o
When an
instance starts up, a memory structure called the System Global Area (SGA) is
allocated.
o
At this
point the background processes also start.
·
An
Oracle Instance provides access to one and only one Oracle database.
Oracle database: An Oracle database consists of files.
·
Sometimes
these are referred to as operating system files, but they are actually database files
that store the database information that a firm or organization needs in order
to operate.
·
The redo log files
are used to recover the database in the event of application program failures,
instance failures and other minor failures.
·
The archived redo log
files are used to recover the database if a disk fails.
·
Other
files not shown in the figure include:
o
The
required parameter
file that is used to specify parameters for configuring an Oracle
instance when it starts up.
o
The
optional password
file authenticates special users of the database these are termed privileged users
and include database administrators.
o
Alert and Trace Log Files these files store information
about errors and actions taken that affect the configuration of the database.
User and server processes: The
processes shown in the figure are called user and server processes.
These processes are used to manage the execution of SQL statements.
·
A Shared Server
Process can share memory and variable processing for multiple user
processes.
·
A Dedicated Server
Process manages memory and variables for a single user process.
This figure from the Oracle Database Administration Guide provides another way of
viewing the SGA.
Connecting to an Oracle Instance
Creating a Session
System users can connect to an Oracle
database through SQLPlus or through an application program like the Internet
Developer Suite (the program becomes the system user). This connection enables users to execute SQL statements.
The act of connecting creates a
communication pathway between a user process and an Oracle Server. As is shown in the figure above, the User
Process communicates with the Oracle Server through a Server Process. The User Process executes on the client
computer. The Server Process executes on
the server computer, and actually executes SQL statements submitted by the
system user.
The figure shows a one-to-one correspondence between the User and Server Processes. This is called a Dedicated Server connection. An alternative configuration is to use a Shared Server where more than one User Process shares a Server Process.
Sessions: When
a user connects to an Oracle server, this is termed a session. The User Global Area is session memory and these
memory structures are described later in this document. The session starts when the Oracle server
validates the user for connection. The
session ends when the user logs out (disconnects) or if the connection
terminates abnormally (network failure or client computer failure).
A user can typically
have more than one concurrent session, e.g., the user may connect using SQLPlus
and also connect using Internet Developer Suite tools at the same time. The limit of concurrent session connections
is controlled by the DBA.
If a system users
attempts to connect and the Oracle Server is not running, the system user
receives the Oracle
Not Available error message.
Physical Structure Database Files
As was noted above, an Oracle database
consists of physical files. The database
itself has:
·
Datafiles these contain the organization's actual
data.
·
Redo log files these contain a chronological record of
changes made to the database, and enable recovery when failures occur.
·
Control files these are used to synchronize all
database activities and are covered in more detail in a later module.
Other key files as noted above include:
·
Parameter
file there are two types
of parameter files.
o
The init.ora
file (also called the PFILE) is a static parameter file. It contains parameters that specify how the
database instance is to start up. For
example, some parameters will specify how to allocate memory to the various
parts of the system global area.
o
The spfile.ora
is a dynamic
parameter file. It also
stores parameters to specify how to startup a database; however, its parameters
can be modified while the database is running.
·
Password
file specifies which
*special* users are authenticated to startup/shut down an Oracle Instance.
·
Archived
redo log files these are
copies of the redo log files and are necessary for recovery in an online,
transaction-processing environment in the event of a disk failure.
Memory Management
and Memory Structures
Oracle
Database Memory Management
Memory management - focus is to
maintain optimal sizes for memory structures.
·
Memory is managed based on memory-related initialization parameters.
·
These values are stored in the init.ora file for each
database.
Three basic options for memory management are as follows:
·
Automatic
memory management:
o
DBA specifies the target size for instance memory.
o
The database instance automatically tunes to the target
memory size.
o
Database redistributes memory as needed between the SGA
and the instance PGA.
·
Automatic
shared memory management:
o
This management mode is partially automated.
o
DBA specifies the target size for the SGA.
o
DBA can optionally set an aggregate target size for the
PGA or managing PGA work areas individually.
·
Manual
memory management:
o
Instead of setting the total memory size, the DBA sets
many initialization parameters to manage components of the SGA and instance PGA
individually.
If you create a database with Database Configuration Assistant (DBCA) and
choose the basic installation option, then automatic memory management is the
default.
The memory
structures include three areas of memory:
·
System Global Area (SGA) this is allocated when an
Oracle Instance starts up.
·
Program Global Area (PGA) this is allocated when a
Server Process starts up.
·
User Global Area (UGA) this is allocated when a
user connects to create a session.
System Global Area
The SGA is a read/write memory area that stores
information shared by all database processes and by all users of the database
(sometimes it is called the Shared Global Area).
o
This information
includes both organizational data and control information used by the Oracle
Server.
o
The SGA
is allocated in memory and virtual memory.
o
The
size of the SGA can be established by a DBA by assigning a value to the
parameter SGA_MAX_SIZE in the parameter filethis is an optional
parameter.
The SGA is
allocated when an Oracle instance (database) is started up based on values
specified in the initialization parameter file (either PFILE or SPFILE).
The SGA has the
following mandatory memory structures:
·
Database Buffer Cache
·
Redo Log Buffer
·
Java Pool
·
Streams Pool
·
Shared Pool includes two components:
o Library Cache
o Data Dictionary
Cache
·
Other structures (for example, lock and latch
management, statistical data)
Additional optional memory structures in the SGA include:
·
Large Pool
The SHOW SGA SQL command will show you the SGA memory
allocations.
·
This is
a recent clip of the SGA for the DBORCL database at SIUE.
·
In
order to execute SHOW SGA you must be connected with the special privilege SYSDBA
(which is only available to user accounts that are members of the DBA Linux
group).
SQL> connect / as sysdba
Connected.
SQL> show sga
Total System Global Area<PHONE_NUMBER> bytes
Fixed Size
2084296 bytes
Variable Size<PHONE_NUMBER>
bytes
Database Buffers
587202560 bytes
Redo Buffers
14692352 bytes
Early versions of
Oracle used a Static SGA. This meant that if modifications to memory
management were required, the database had to be shutdown, modifications were
made to the init.ora parameter file, and
then the database had to be restarted.
Oracle 11g uses a Dynamic SGA.
Memory configurations for the system global area can be made without
shutting down the database instance. The
DBA can resize the Database Buffer Cache and Shared Pool dynamically.
Several
initialization parameters are set that affect the amount of random access
memory dedicated to the SGA of an Oracle Instance. These are:
·
SGA_MAX_SIZE:
This optional parameter is used to set a limit on the amount of virtual memory
allocated to the SGA a typical setting might be 1 GB; however, if the value for SGA_MAX_SIZE in the initialization parameter file or
server parameter file is less than the sum the memory allocated for all
components, either explicitly in the parameter file or by default, at the time
the instance is initialized, then the database ignores the setting for
SGA_MAX_SIZE. For optimal performance,
the entire SGA should fit in real memory to eliminate paging to/from disk by
the operating system.
·
DB_CACHE_SIZE:
This optional parameter is used to tune the amount memory allocated to
the Database Buffer Cache in standard database blocks. Block sizes vary among operating systems. The DBORCL database uses 8 KB blocks. The total blocks in the cache defaults to 48 MB
on LINUX/UNIX and 52 MB on Windows operating systems.
·
LOG_BUFFER:
This optional parameter specifies the number of bytes allocated for the
Redo Log Buffer.
·
SHARED_POOL_SIZE:
This optional parameter specifies the number of bytes of memory
allocated to shared SQL and PL/SQL. The
default is 16
MB. If the operating system
is based on a 64
bit configuration, then the default size is 64 MB.
·
LARGE_POOL_SIZE:
This is an optional memory object the size of the Large Pool defaults
to zero. If the init.ora parameter PARALLEL_AUTOMATIC_TUNING
is set to TRUE,
then the default size is automatically calculated.
·
JAVA_POOL_SIZE:
This is another optional memory object.
The default is 24 MB of memory.
The size of the SGA cannot exceed the
parameter SGA_MAX_SIZE
minus the combination of the size of the additional parameters, DB_CACHE_SIZE,
LOG_BUFFER,
SHARED_POOL_SIZE,
LARGE_POOL_SIZE,
and JAVA_POOL_SIZE.
Memory is allocated
to the SGA as contiguous virtual memory in units termed granules. Granule size depends on the estimated total
size of the SGA, which as was noted above, depends on the SGA_MAX_SIZE
parameter. Granules are sized as
follows:
·
If the SGA is less than 1
GB in total, each granule is 4 MB.
·
If the SGA is greater than 1 GB in total, each granule is 16 MB.
Granules are assigned to the Database Buffer
Cache, Shared Pool, Java Pool, and other memory structures, and these memory components
can dynamically grow and shrink. Using
contiguous memory improves system performance.
The actual number of granules assigned to one of these memory components
can be determined by querying the database view named V$BUFFER_POOL.
Granules are allocated when the Oracle
server starts a database instance in order to provide memory addressing space
to meet the SGA_MAX_SIZE parameter. The
minimum is 3 granules: one each for the
fixed SGA, Database Buffer Cache, and Shared Pool. In practice, you'll find the SGA is allocated
much more memory than this. The SELECT
statement shown below shows a current_size of 1,152 granules.
SELECT name, block_size, current_size, prev_size, prev_buffers
FROM v$buffer_pool;
NAME
BLOCK_SIZE CURRENT_SIZE PREV_SIZE
PREV_BUFFERS
-------------------- ---------- ------------ ---------- ------------
DEFAULT
8192<PHONE_NUMBER>4
For additional information on the dynamic
SGA sizing, enroll in Oracle's Oracle11g Database Performance Tuning course.
Program Global Area (PGA)
A PGA is:
·
a nonshared
memory region that contains data and control information exclusively for use by
an Oracle process.
·
A PGA
is created by Oracle Database when an Oracle process is started.
·
One
PGA exists for each Server Process and each Background Process. It stores data and control information for a
single Server
Process or a single Background Process.
·
It is
allocated when a process is created and the memory is scavenged by the
operating system when the process terminates.
This is NOT a shared
part of memory one PGA to each process only.
·
The
collection of individual PGAs is the total
instance PGA, or instance PGA.
·
Database
initialization parameters set the size of the instance PGA, not individual
PGAs.
The Program Global Area
is also termed the Process Global Area (PGA) and is a part of memory
allocated that is outside of the Oracle Instance.
The content of the
PGA varies, but as shown in the figure above, generally includes the following:
·
Private SQL Area: Stores
information for a parsed SQL statement stores bind variable values and
runtime memory allocations. A user
session issuing SQL statements has a Private SQL Area that may be associated
with a Shared SQL Area if the same SQL statement is being executed by more than
one system user. This often happens in
OLTP environments where many users are executing and using the same application
program.
o Dedicated
Server environment
the Private SQL Area is located in the Program Global Area.
o Shared
Server environment
the Private SQL Area is located in the System Global Area.
·
Session Memory:
Memory that holds session variables and other session information.
·
SQL Work Areas:
Memory allocated for sort, hash-join, bitmap merge, and bitmap create
types of operations.
o Oracle 9i and later versions enable
automatic sizing of the SQL Work Areas by setting the WORKAREA_SIZE_POLICY = AUTO
parameter (this is the default!) and PGA_AGGREGATE_TARGET = n (where n is some amount
of memory established by the DBA). However,
the DBA can let the Oracle DBMS determine the appropriate amount of memory.
User Global Area
The User Global Area
is session memory.
A session that loads a PL/SQL package into memory has the package state stored to the UGA.
The package state is the set of values stored
in all the package variables at a specific time. The state changes as program
code the variables. By default, package variables are unique to and persist for
the life of the session.
The OLAP page pool
is also stored in the UGA. This pool manages OLAP data
pages, which are equivalent to data blocks. The page pool is allocated at the
start of an OLAP session and released at the end of the session. An OLAP session opens automatically whenever
a user queries a dimensional object such as a cube.
Note: Oracle OLAP is a multidimensional
analytic engine embedded in Oracle Database 11g.
Oracle OLAP cubes deliver sophisticated calculations using simple SQL
queries - producing results with speed of thought response times.
The UGA must be available to a database
session for the life of the session. For
this reason, the UGA cannot be stored in the PGA when using a shared server
connection because the PGA is specific to a single process. Therefore, the UGA is stored in the SGA when
using shared server connections, enabling any shared server process access to
it. When using a dedicated server
connection, the UGA is stored in the PGA.
Automatic
Shared Memory Management
Prior to Oracle 10G, a DBA had to manually specify SGA Component sizes
through the initialization parameters, such as SHARED_POOL_SIZE, DB_CACHE_SIZE,
JAVA_POOL_SIZE, and LARGE_POOL_SIZE parameters.
Automatic
Shared Memory Management enables a DBA to specify the total SGA memory
available through the SGA_TARGET initialization parameter. The Oracle Database automatically distributes
this memory among various subcomponents to ensure most effective memory
utilization.
The DBORCL
database SGA_TARGET
is set in the initDBORCL.ora
file:
sga_target=1610612736
With automatic SGA memory management, the different SGA components are
flexibly sized to adapt to the SGA available.
Setting a single
parameter simplifies the administration task the DBA only specifies the
amount of SGA memory available to an instance the DBA can forget about the
sizes of individual components. No out of memory errors are generated unless
the system has actually run out of memory.
No manual tuning effort is needed.
The SGA_TARGET
initialization parameter reflects the total size of the SGA and includes memory
for the following components:
If SGA_TARGET
is set to a value greater than SGA_MAX_SIZE at startup, then the SGA_MAX_SIZE
value is bumped up to accommodate SGA_TARGET.
When you set a value for SGA_TARGET, Oracle Database 11g
automatically sizes the most commonly configured components, including:
There are a few SGA components whose sizes are not automatically adjusted.
The DBA must specify the sizes of these components explicitly, if they are
needed by an application. Such components are:
The granule size that is currently being used for the SGA
for each component can be viewed in the view V$SGAINFO. The size of each component and the time and
type of the last resize operation performed on each component can be viewed in
the view V$SGA_DYNAMIC_COMPONENTS.
SQL> select * from v$sgainfo;
More...
NAME BYTES RES
--------------------------------
---------- ---
Fixed SGA Size 2084296 No
Redo Buffers 14692352 No
Buffer Cache Size 587202560 Yes
Shared Pool Size 956301312 Yes
Large Pool Size 16777216 Yes
Java Pool Size 33554432 Yes93
Streams Pool Size 0 Yes
Granule Size 16777216 No
Maximum SGA Size<PHONE_NUMBER> No
Startup overhead in Shared
Pool 67108864 No
Free SGA Memory Available 0
11 rows selected.
Shared Pool
The Shared Pool
is a memory structure that is shared by all system users.
·
It caches various types of program data.
For example, the shared pool stores parsed SQL, PL/SQL code, system parameters,
and data dictionary
information.
·
The shared pool is involved in almost every
operation that occurs in the database. For example, if a user executes a SQL
statement, then Oracle Database accesses the shared pool.
·
It
consists of both fixed and variable structures.
·
The
variable component grows and shrinks depending on the demands placed on memory
size by system users and application programs.
Memory can be
allocated to the Shared Pool by the parameter SHARED_POOL_SIZE in the parameter
file. The default
value of this parameter is 8MB on
32-bit platforms and 64MB on
64-bit platforms. Increasing the value of this parameter increases the amount
of memory reserved for the shared pool.
You can alter the
size of the shared pool dynamically with the ALTER SYSTEM SET command. An example command is shown in the figure
below. You must keep in mind that the
total memory allocated to the SGA is set by the SGA_TARGET parameter (and may also be limited by the SGA_MAX_SIZE if
it is set), and since the Shared Pool is part of the SGA, you cannot exceed the
maximum size of the SGA. It is
recommended to let Oracle optimize the Shared Pool size.
The Shared Pool
stores the most recently executed SQL statements and used data
definitions. This is because some system
users and application programs will tend to execute the same SQL statements
often. Saving this information in memory
can improve system performance.
The Shared Pool
includes several cache areas described below.
Library
Cache
Memory is allocated
to the Library
Cache whenever an SQL statement is parsed or a program unit is
called. This enables storage of the most
recently used SQL and PL/SQL statements.
If the Library
Cache is too small, the Library Cache must purge statement definitions in order
to have space to load new SQL and PL/SQL statements. Actual management of this memory structure is
through a Least-Recently-Used
(LRU) algorithm. This means
that the SQL and PL/SQL statements that are oldest and least recently used are
purged when more storage space is needed.
The Library Cache
is composed of two memory subcomponents:
·
Shared SQL: This stores/shares the execution plan and
parse tree for SQL statements, as well as PL/SQL statements such as functions,
packages, and triggers. If a system user
executes an identical statement, then the statement does not have to be parsed
again in order to execute the statement.
·
Private SQL Area:
With a shared server, each session issuing a SQL statement
has a private SQL area in its PGA.
o
Each user that submits the same statement
has a private SQL area pointing to the same shared SQL area.
o
Many private SQL areas in separate PGAs can
be associated with the same shared SQL area.
o
This figure depicts two different client
processes issuing the same SQL statement the parsed solution is already in
the Shared SQL Area.
Data
Dictionary Cache
The Data Dictionary
Cache is a memory structure that caches data dictionary information that has
been recently used.
·
This
cache is necessary because the data dictionary is accessed so often.
·
Information
accessed includes user account information, datafile names, table descriptions,
user privileges, and other information.
The database server
manages the size of the Data Dictionary Cache internally and the size depends
on the size of the Shared Pool in which the Data Dictionary Cache resides. If the size is too small, then the data
dictionary tables that reside on disk must be queried often for information and
this will slow down performance.
Server
Result Cache
The Server
Result Cache holds result sets and not data blocks. The server
result cache contains the SQL query result cache and PL/SQL function result cache, which share the same
infrastructure.
SQL Query Result Cache
This cache stores the results of queries and query
fragments.
·
Using the cache results for future queries
tends to improve performance.
·
For example, suppose an application runs
the same SELECT statement repeatedly. If the results are cached, then the
database returns them immediately.
·
In this way, the database avoids the
expensive operation of rereading blocks and recomputing results.
PL/SQL Function Result Cache
The
PL/SQL
Function Result Cache stores function result sets.
·
Without
caching, 1000 calls of a function at 1 second per call would take 1000 seconds.
·
With
caching, 1000 function calls with the same inputs could take 1 second total.
·
Good
candidates for result caching are frequently invoked functions that depend on
relatively static data.
·
PL/SQL
function code can specify that results be cached.
Buffer Caches
A number of buffer
caches are maintained in memory in order to improve system response time.
Database
Buffer Cache
The Database Buffer
Cache is a fairly large memory object that stores the actual data blocks
that are retrieved from datafiles by system queries and other data manipulation
language commands.
The purpose is to
optimize physical input/output of data.
When Database Smart
Flash Cache (flash cache) is enabled, part
of the buffer cache can reside in the flash cache.
·
This buffer cache extension is stored on a flash disk
device, which is a solid state storage device that uses flash memory.
·
The database can improve performance by caching buffers
in flash memory instead of reading from magnetic disk.
·
Database Smart Flash Cache is available only in Solaris
and Oracle Enterprise Linux.
A query causes a Server Process
to look for data.
·
The first
look is in the Database Buffer Cache to determine if the requested information
happens to already be located in memory thus the information would not need
to be retrieved from disk and this would speed up performance.
·
If the
information is not in the Database Buffer Cache, the Server Process retrieves
the information from disk and stores it to the cache.
·
Keep in
mind that information read from disk is read a block at a time, NOT a row
at a time, because a database block is the smallest addressable storage
space on disk.
Database blocks are
kept in the Database Buffer Cache according to a Least Recently Used (LRU) algorithm and
are aged out of memory if a buffer cache block is not used in order to provide
space for the insertion of newly needed database blocks.
There are three
buffer states:
·
Unused - a buffer is available for use - it has
never been used or is currently unused.
·
Clean - a buffer that was used earlier - the data
has been written to disk.
·
Dirty - a buffer that has modified data that has not
been written to disk.
Each buffer has one
of two access modes:
·
Pinned - a buffer is pinned so it does not age out
of memory.
·
Free (unpinned).
The buffers in the cache are organized in two lists:
· the write list and,
· the least recently used (LRU) list.
The write list (also called a write queue) holds dirty buffers these are buffers that hold that data that has been modified, but the blocks have not been written back to disk.
The LRU list holds unused, free clean buffers, pinned buffers, and free dirty buffers that have not yet been moved to the write list. Free clean buffers do not contain any useful data and are available for use. Pinned buffers are currently being accessed.
When an Oracle process accesses a buffer, the process moves the buffer to the most recently used (MRU) end of the LRU list this causes dirty buffers to age toward the LRU end of the LRU list.
When an Oracle user process needs a data row, it searches for the data in the database buffer cache because memory can be searched more quickly than hard disk can be accessed. If the data row is already in the cache (a cache hit), the process reads the data from memory; otherwise a cache miss occurs and data must be read from hard disk into the database buffer cache.
Before reading a data block into the cache, the process must first find a free buffer. The process searches the LRU list, starting at the LRU end of the list. The search continues until a free buffer is found or until the search reaches the threshold limit of buffers.
Each time a user process finds a dirty buffer as it searches the LRU, that buffer is moved to the write list and the search for a free buffer continues.
When a user process finds a free buffer, it reads the data block from disk into the buffer and moves the buffer to the MRU end of the LRU list.
If an Oracle user process searches the threshold limit of buffers without finding a free buffer, the process stops searching the LRU list and signals the DBWn background process to write some of the dirty buffers to disk. This frees up some buffers.
Database
Buffer Cache Block Size
The block size for
a database is set when a database is created and is determined by the init.ora
parameter file parameter named DB_BLOCK_SIZE.
·
Typical
block sizes are 2KB,
4KB,
8KB,
16KB,
and 32KB.
·
The
size of blocks in the Database Buffer Cache matches the block size for the
database.
·
The DBORCL
database uses an 8KB block size.
·
This
figure shows that the use of non-standard block sizes results in multiple
database buffer cache memory allocations.
Because tablespaces
that store oracle tables can use different (non-standard) block sizes, there
can be more than one Database Buffer Cache allocated to match block sizes in
the cache with the block sizes in the non-standard tablespaces.
The size of the
Database Buffer Caches can be controlled by the parameters DB_CACHE_SIZE and DB_nK_CACHE_SIZE
to dynamically change the memory allocated to the caches without restarting the
Oracle instance.
You can dynamically
change the size of the Database Buffer Cache with the ALTER SYSTEM command like
the one shown here:
ALTER SYSTEM SET DB_CACHE_SIZE = 96M;
You can have the
Oracle Server gather statistics about the Database Buffer Cache to help you
size it to achieve an optimal workload for the memory allocation. This information is displayed from the V$DB_CACHE_ADVICE
view. In order for statistics to be
gathered, you can dynamically alter the system by using the ALTER SYSTEM SET
DB_CACHE_ADVICE (OFF, ON, READY) command. However, gathering statistics on system
performance always incurs some overhead that will slow down system performance.
SQL> ALTER SYSTEM SET
db_cache_advice = ON;
System altered.
SQL> DESC V$DB_cache_advice;
Name
Null? Type
-----------------------------------------
-------- -------------
ID
NUMBER
NAME
VARCHAR2(20)
BLOCK_SIZE NUMBER
ADVICE_STATUS
VARCHAR2(3)
SIZE_FOR_ESTIMATE NUMBER
SIZE_FACTOR NUMBER
BUFFERS_FOR_ESTIMATE NUMBER
ESTD_PHYSICAL_READ_FACTOR NUMBER
ESTD_PHYSICAL_READS NUMBER
ESTD_PHYSICAL_READ_TIME NUMBER
ESTD_PCT_OF_DB_TIME_FOR_READS NUMBER
ESTD_CLUSTER_READS NUMBER
ESTD_CLUSTER_READ_TIME NUMBER
SQL> SELECT name, block_size,
advice_status FROM v$db_cache_advice;
NAME BLOCK_SIZE ADV
-------------------- ---------- ---
DEFAULT 8192 ON
<more rows will display>
21 rows selected.
SQL> ALTER SYSTEM SET
db_cache_advice = OFF;
System altered.
KEEP
Buffer Pool
This pool retains blocks
in memory (data from tables) that are likely to be reused throughout daily
processing. An example might be a table
containing user names and passwords or a validation table of some type.
The DB_KEEP_CACHE_SIZE
parameter sizes the KEEP Buffer Pool.
RECYCLE
Buffer Pool
This pool is used
to store table data that is unlikely to be reused throughout daily processing
thus the data blocks are quickly removed from memory when not needed.
The DB_RECYCLE_CACHE_SIZE
parameter sizes the Recycle Buffer Pool.
Redo Log Buffer
The Redo Log Buffer
memory object stores images of all changes made to database blocks.
·
Database
blocks typically store several table rows of organizational data. This means that if a single column value from
one row in a block is changed, the block image is stored. Changes include INSERT, UPDATE, DELETE,
CREATE, ALTER, or DROP.

The Redo Log Buffer
as a circular buffer that is reused over and over. As the buffer fills up, copies of the images
are stored to the Redo Log Files that are covered in more detail in
a later module.
Large Pool
The Large Pool
is an optional memory structure that primarily relieves the memory burden
placed on the Shared Pool. The Large
Pool is used for the following tasks if it is allocated:
·
Allocating
space for session memory requirements from the User Global Area where a Shared
Server is in use.
·
Transactions
that interact with more than one database, e.g., a distributed database
scenario.
·
Backup
and restore operations by the Recovery Manager (RMAN) process.
o RMAN uses this only if the BACKUP_DISK_IO = n
and BACKUP_TAPE_IO_SLAVE
= TRUE parameters are set.
o If the Large Pool is too small, memory
allocation for backup will fail and memory will be allocated from the Shared
Pool.
·
Parallel
execution message buffers for parallel server operations. The PARALLEL_AUTOMATIC_TUNING = TRUE parameter must be
set.
The Large Pool size
is set with the LARGE_POOL_SIZE
parameter this is not a dynamic parameter.
It does not use an LRU list to manage memory.
Java Pool
The Java Pool is an
optional memory object, but is
required if the database has Oracle Java installed and in use for Oracle JVM
(Java Virtual Machine).
·
The
size is set with the JAVA_POOL_SIZE parameter that defaults to 24MB.
·
The
Java Pool is used for memory allocation to parse Java commands and to store
data associated with Java commands.
·
Storing
Java code and data in the Java Pool is analogous to SQL and PL/SQL code cached
in the Shared Pool.
Streams Pool
This pool stores
data and control structures to support the Oracle Streams feature of Oracle
Enterprise Edition.
·
Oracle
Steams manages sharing of data and events in a distributed environment.
·
It is
sized with the parameter STREAMS_POOL_SIZE.
·
If
STEAMS_POOL_SIZE is not set or is zero, the size of the pool grows dynamically.
Processes
You need to understand
three different types of Processes:
·
User Process:
Starts when a database user requests to connect to an Oracle Server.
·
Server Process:
Establishes the Connection to an Oracle Instance when a User Process
requests connection makes the connection for the User Process.
·
Background Processes:
These start when an Oracle Instance is started up.
Client Process
In order to use
Oracle, you must connect to the database.
This must occur whether you're using SQLPlus, an Oracle tool such as Designer
or Forms, or an application program. The
client process is also termed the user process in some Oracle documentation.
This generates a
User Process (a memory object) that generates programmatic calls through your
user interface (SQLPlus, Integrated Developer Suite, or application program)
that creates a session and causes the generation of a Server Process that is
either dedicated or shared.
Server Process
A Server Process is the go-between for a
Client Process and the Oracle Instance.
·
Dedicated
Server environment there is a single Server Process to serve each Client
Process.
·
Shared
Server environment a Server Process can serve several User Processes,
although with some performance reduction.
·
Allocation
of server process in a dedicated environment versus a shared environment is
covered in further detail in the Oracle11g Database Performance Tuning course
offered by Oracle Education.
Background Processes
As is shown here, there are both mandatory, optional, and slave background processes that are started whenever an Oracle Instance starts up. These background processes serve all system users. We will cover mandatory process in detail.

·
It is a
cleanup type of process that cleans up after failed processes.
·
Examples
include the dropping of a user connection due to a network failure or the
abnormal termination (ABEND) of a user application program.
·
It
cleans up the database buffer cache and releases resources that were used by a
failed user process.
·
It does
the tasks shown in the figure below.
SMON
The System Monitor
(SMON) does system-level cleanup duties.
·
It is
responsible for instance recovery by applying entries in the online redo log
files to the datafiles.
·
Other
processes can call SMON when it is needed.
·
It also
performs other activities as outlined in the figure shown below.
If an Oracle
Instance fails, all information in memory not written to disk is lost. SMON is responsible for recovering the
instance when the database is started up again.
It does the following:
·
Rolls
forward to recover data that was recorded in a Redo Log File, but that had not
yet been recorded to a datafile by DBWn.
SMON reads the Redo Log Files and applies the changes to the data
blocks. This recovers all transactions
that were committed because these were written to the Redo Log Files prior to
system failure.
·
Opens
the database to allow system users to logon.
·
Rolls
back uncommitted transactions.
SMON also does
limited space management. It combines
(coalesces) adjacent areas of free space in the database's datafiles for
tablespaces that are dictionary managed.
It also deallocates
temporary segments to create free space in the datafiles.
DBWn (also called DBWR in earlier Oracle Versions)
The Database Writer writes modified blocks from the database buffer cache to the datafiles.
· One database writer process (DBW0) is sufficient for most systems.
· A DBA can configure up to 20 DBWn processes (DBW0 through DBW9 and DBWa through DBWj) in order to improve write performance for a system that modifies data heavily.
·
The initialization parameter DB_WRITER_PROCESSES
specifies the number of DBWn
processes.
The purpose of DBWn is to improve system
performance by caching writes of database blocks from the Database Buffer Cache back to
datafiles.
·
Blocks
that have been modified and that need to be written back to disk are termed
"dirty
blocks."
·
The
DBWn also ensures that there are enough free buffers in the Database Buffer
Cache to service Server Processes that may be reading data from datafiles into
the Database Buffer Cache.
·
Performance
improves because by delaying writing changed database blocks back to disk, a
Server Process may find the data that is needed to meet a User Process request
already residing in memory!
·
DBWn
writes to datafiles when one of these events occurs that is illustrated in the
figure below.
LGWR
The Log Writer (LGWR)
writes contents from the Redo Log Buffer to the Redo Log File that is in
use.
·
These
are sequential writes since the Redo Log Files record database modifications
based on the actual time that the modification takes place.
·
LGWR
actually writes before the DBWn writes and only confirms that a COMMIT
operation has succeeded when the Redo Log Buffer contents are successfully
written to disk.
·
LGWR
can also call the DBWn to write contents of the Database Buffer Cache to
disk.
·
The
LGWR writes according to the events illustrated in the figure shown below.
CKPT
The Checkpoint (CPT)
process writes information to update the database control files and headers of
datafiles.
·
A
checkpoint identifies a point in time with regard to the Redo Log Files where instance
recovery is to begin should it be necessary.
·
It can
tell DBWn to write blocks to disk.
·
A
checkpoint is taken at a minimum, once every three seconds.
Think of a
checkpoint record as a starting point for recovery. DBWn will have completed writing all buffers
from the Database Buffer Cache to disk prior to the checkpoint, thus those
records will not require recovery. This
does the following:
·
Ensures
modified data blocks in memory are regularly written to disk CKPT can call
the DBWn process in order to ensure this and does so when writing a checkpoint
record.
·
Reduces
Instance Recovery time by minimizing the amount of work needed for recovery
since only Redo Log File entries processed since the last checkpoint require
recovery.
·
Causes
all committed data to be written to datafiles during database shutdown.
If a Redo Log File
fills up and a switch is made to a new Redo Log File (this is covered in more
detail in a later module), the CKPT process also writes checkpoint information
into the headers of the datafiles.
Checkpoint
information written to control files includes the system change number (the SCN
is a number stored in the control file and in the headers of the database files
that are used to ensure that all files in the system are synchronized),
location of which Redo Log File is to be used for recovery, and other
information.
CKPT does not write
data blocks or redo blocks to disk it calls DBWn and LGWR as necessary.
MMON and MMNL
The Manageability
Monitor Process (MMNO) performs tasks related to the Automatic Workload Repository (AWR)
a repository of statistical data in the SYSAUX tablespace (see figure below)
for example, MMON writes when a metric violates its
threshold value, taking snapshots, and capturing statistics value for recently
modified SQL objects.
The Manageability
Monitor Lite Process (MMNL) writes statistics from the Active
Session History (ASH) buffer in the SGA to disk. MMNL writes to disk when the
ASH buffer is full.
The information stored by these processes is used for
performance tuning we survey performance tuning in a later module.
RECO
The Recoverer
Process (RECO) is used to resolve failures of distributed
transactions in a distributed database.
·
Consider a database that is distributed on
two servers one in St. Louis and one in Chicago.
·
Further, the database may be distributed on
servers of two different operating systems, e.g. LINUX and Windows.
·
The RECO process of a node automatically
connects to other databases involved in an in-doubt distributed transaction.
·
When RECO reestablishes a connection
between the databases, it automatically resolves all in-doubt transactions,
removing from each database's pending transaction table any rows that correspond
to the resolved transactions.
Optional Background
Processes
Optional Background Process Definition:
·
ARCn: Archiver One or more archiver
processes copy the online redo log files to archival storage when they are full
or a log switch occurs.
· CJQ0: Coordinator Job Queue This is the coordinator of job queue processes for an instance. It monitors the JOB$ table (table of jobs in the job queue) and starts job queue processes (Jnnn) as needed to execute jobs The Jnnn processes execute job requests created by the DBMS_JOBS package.
· Dnnn: Dispatcher number "nnn", for example, D000 would be the first dispatcher process Dispatchers are optional background processes, present only when the shared server configuration is used. Shared server is discussed in your readings on the topic "Configuring Oracle for the Shared Server".
·
FBDA: Flashback Data Archiver Process This archives historical rows of tracked tables into
Flashback Data Archives. When a transaction containing DML on a tracked table
commits, this process stores the pre-image of the rows into the Flashback Data
Archive. It also keeps metadata on the current rows. FBDA automatically manages the flashback data
archive for space, organization, and retention
Of these, you will most often use ARCn
(archiver) when you automatically archive redo log file information (covered in
a later module).
ARCn
While the Archiver (ARCn)
is an optional background process, we cover it in more detail because it is
almost always used for production systems storing mission critical
information.
·
The
ARCn process must be used to recover from loss of a physical disk drive for
systems that are "busy" with lots of transactions being completed.
·
It
performs the tasks listed below.
When a Redo Log
File fills up, Oracle switches to the next Redo Log File.
·
The DBA
creates several of these and the details of creating them are covered in a
later module.
·
If all
Redo Log Files fill up, then Oracle switches back to the first one and uses
them in a round-robin fashion by overwriting ones that have already been used.
·
Overwritten
Redo Log Files have information that, once overwritten, is lost forever.
ARCHIVELOG Mode:
·
If ARCn
is in what is termed ARCHIVELOG mode, then as the Redo Log Files fill
up, they are individually written to Archived Redo Log Files.
·
LGWR
does not overwrite a Redo Log File until archiving has completed.
·
Committed
data is not lost forever and can be recovered in the event of a disk
failure.
·
Only
the contents of the SGA will be lost if an Instance fails.
In NOARCHIVELOG
Mode:
·
The
Redo Log Files are overwritten and not
archived.
·
Recovery
can only be made to the last full backup of the database files.
·
All
committed transactions after the last full backup are lost, and you can see
that this could cost the firm a lot of $$$.
When running in
ARCHIVELOG mode, the DBA is responsible to ensure that the Archived Redo Log
Files do not consume all available disk space!
Usually after two complete backups are made, any Archived Redo Log Files
for prior backups are deleted.
Slave Processes
Slave processes are background
processes that perform work on behalf of other processes.
Innn: I/O slave processes -- simulate asynchronous
I/O for systems and devices that do not support it. In asynchronous I/O, there is no timing requirement for
transmission, enabling other processes to start before the transmission has
finished.
·
For
example, assume that an application writes 1000 blocks to a disk on an
operating system that does not support asynchronous I/O.
·
Each
write occurs sequentially and waits for a confirmation that the write was successful.
·
With
asynchronous disk, the application can write the blocks in bulk and perform
other work while waiting for a response from the operating system that all
blocks were written.
Parallel Query Slaves --
In parallel
execution or parallel processing, multiple processes work together simultaneously
to run a single SQL statement.
·
By
dividing the work among multiple processes, Oracle Database can run the
statement more quickly.
·
For
example, four processes handle four different quarters in a year instead of one
process handling all four quarters by itself.
·
Parallel
execution reduces response time for data-intensive operations on large
databases such as data warehouses. Symmetric multiprocessing (SMP) and
clustered system gain the largest performance benefits from parallel execution
because statement processing can be split up among multiple CPUs. Parallel
execution can also benefit certain types of OLTP
and hybrid systems.
Logical
Structure
It is helpful to
understand how an Oracle database is organized in terms of a logical structure
that is used to organize physical objects.
Tablespace: An
Oracle database must always consist of at least two tablespaces (SYSTEM and SYSAUX),
although a typical Oracle database will multiple tablespaces.
·
A
tablespace is a logical storage facility (a logical container) for storing
objects such as tables, indexes, sequences, clusters, and other database
objects.
·
Each
tablespace has at least one physical datafile that actually stores the
tablespace at the operating system level.
A large tablespace may have more than one datafile allocated for storing
objects assigned to that tablespace.
·
A
tablespace belongs to only one database.
·
Tablespaces
can be brought online and taken offline for purposes of backup and management,
except for the SYSTEM
tablespace that must always be online.
·
Tablespaces
can be in either read-only or read-write status.
Datafile:
Tablespaces are stored in datafiles which are physical disk
objects.
·
A
datafile can only store objects for a single tablespace, but a tablespace may
have more than one datafile this happens when a disk drive device fills up
and a tablespace needs to be expanded, then it is expanded to a new disk
drive.
·
The DBA
can change the size of a datafile to make it smaller or later. The file can also grow in size dynamically as
the tablespace grows.
Segment:
When logical storage objects are created within a tablespace, for
example, an employee
table, a segment is allocated to the object.
·
Obviously
a tablespace typically has many segments.
·
A
segment cannot span tablespaces but can span datafiles that belong to a single
tablespace.
Extent: Each object has one segment
which is a physical collection of extents.
·
Extents are simply collections of contiguous disk storage blocks. A logical storage object such as a table or
index always consists of at least one extent ideally the initial extent
allocated to an object will be large enough to store all data that is initially
loaded.
·
As a
table or index grows, additional extents are added to the segment.
·
A DBA
can add extents to segments in order to tune performance of the system.
·
An
extent cannot span a datafile.
Block: The Oracle Server manages data
at the smallest unit in what is termed a block or data block.
Data are actually stored in blocks.
A physical
block
is the smallest addressable location on a disk drive for read/write
operations.
An Oracle data
block consists of one or more physical blocks (operating system blocks) so the
data block, if larger than an operating system block, should be an even
multiple of the operating system block size, e.g., if the Linux operating
system block size is 2K or 4K, then the Oracle data block should be 2K, 4K, 8K,
16K, etc in size. This optimizes I/O.
The data block size
is set at the time the database is created and cannot be changed. It is set with the DB_BLOCK_SIZE parameter. The maximum data block size depends on the
operating system.
Thus, the Oracle
database architecture includes both logical and physical structures as follows:
·
Physical: Control files; Redo Log Files; Datafiles;
Operating System Blocks.
·
Logical: Tablespaces; Segments; Extents; Data Blocks.
SQL
Statement Processing
SQL Statements are
processed differently depending on whether the statement is a query, data
manipulation language (DML) to update, insert, or delete a row, or data
definition language (DDL) to write information to the data
dictionary.
Processing a query:
·
Parse:
o
Search
for identical statement in the Shared SQL Area.
o
Check
syntax, object names, and privileges.
o
Lock
objects used during parse.
o
Create
and store execution plan.
·
Bind:
Obtains values for variables.
·
Execute:
Process statement.
·
Fetch:
Return rows to user process.
Processing a DML statement:
·
Parse:
Same as the parse phase used for processing a query.
·
Bind:
Same as the bind phase used for processing a query.
·
Execute:
o
If the data
and undo blocks are not already in the Database Buffer Cache, the server
process reads them from the datafiles into the Database Buffer Cache.
o
The
server process places locks on the rows that are to be modified. The undo block
is used to store the before image of the data, so that the DML statements can
be rolled back if necessary.
o
The
data blocks record the new values of the data.
o
The
server process records the before image to the undo block and updates the data
block. Both of these changes are made in
the Database Buffer Cache. Any changed
blocks in the Database Buffer Cache are marked as dirty buffers. That is, buffers that are not the same as the
corresponding blocks on the disk.
o
The
processing of a DELETE or INSERT command uses similar steps. The before image for a DELETE contains the
column values in the deleted row, and the before image of an INSERT contains
the row location information.
Processing a DDL statement:
·
The
execution of DDL (Data Definition Language) statements differs from the execution
of DML (Data Manipulation Language) statements and queries, because the success
of a DDL statement requires write access to the data dictionary.
·
For
these statements, parsing actually includes parsing, data dictionary lookup,
and execution. Transaction management,
session management, and system management SQL statements are processed using
the parse and execute stages. To
re-execute them, simply perform another execute.
END OF NOTES


Saved Correctly
Saving Failed
Error in red field
Json file uploaded is invalid
Error in token generation
Operation authorized for the role but you haven't got a policy. Please contact the administrator!
Select File to be uploaded
Upload
Folder Destination
Select File Json to be uploaded
Upload
Select Policy File
Policy selected


BABY BOOM A film review by Miriam Nadel Copyright 1987 Miriam Nadel
By now you probably know the premise. Diane Keaton plays J. C. Wiatt, "The Tiger Lady," and a stereotyped yuppie marketing manager, on the verge of being promoted to a partnership in her agency. Then she inherits a baby from a distant relative. Ignoring the suspension of disbelief inherent in the way the movie shows the adoption process, J.C. ends up trying to be super-Mom--and still work 70 hours a week.
The plot turns on J.C. finding a clever way to deal with her situation. There is also a romantic interest, J.C.'s live-in lover having walked out once the baby came. Unfortunately, the ending is completely predictable by the middle of the movie, though it's still handled well.
The pluses--some very funny moments, especially those centering on yuppie cliches (e.g. J.C. learning about how important it is to get baby Elizabeth into the "right" pre-school), a nice conciousness of feminist values (which includes some indication of men as nurturing parents as well) and some nice scenery in Vermont.
The minuses--the baby is just a little too sweet, the plot is a little too pat, Diane Keaton is far too unbelievable in her "successful businesswoman" persona (unless you think that marketing executives stammer and giggle "gee, that's really great" when a potential promotion is discussed) and nobody in the cast had ever bothered to find out what a Vermont accent really sounds like.
Overall, the plusses outweigh the minuses. 3 stars.
<EMAIL_ADDRESS>{philabs, trwrb}!cadovax!gryphon!mhnadel {hplabs!hp-sdd, sdcsvax, ihnp4, nosc}!crash!gryphon!mhnadel
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


---
title: core
keywords: fastai
sidebar: home_sidebar
summary: "One more test of nbdev"
description: "One more test of nbdev"
nb_path: "00_core.ipynb"
---
Finds and returns the class object that will provide
the definition of method_name (as a string) if it is
invoked on obj.
obj: any python object
method_name: string method name
{% endraw %}
{% raw %}
<class '__main__.Deck'>
Ace of Clubs
3 of Diamonds
9 of Hearts
King of Hearts
4 of Spades


A REVIEW OF "MESSAGE IN A BOTTLE" by Ryan Ellis
give me a buzz on the ol' e-lines<EMAIL_ADDRESS>Studio executives have one eye stuck on their profit summary and the other eye stuck on their calendar. With no small measure of coincidence, they release certain pictures at the time of holidays or observances. "Fathers' Day" was released around--get this!--Fathers' Day, "Independence Day" debutted on the July 4th weekend, and Christmas flicks come out in December. Therefore, it was fitting that "Message In A Bottle" swept into theatres on the Valentines' Day weekend. A romantic love story, this picture is for lovers to attend and hold hands and cry together and whatnot. BUT, don't call this a date movie--at least, a FIRST date movie. It's not really '99s version of "Sleepless In Seattle" or even "You've Got Mail". This piece of work is painful to watch. I wouldn't want to go to see this film on a first date (or even a second) with a woman I don't know that well. The funny moments are few and far between and they've set some kind of record for tears shed in one movie. However, don't take that for negative criticism--this is an old-fashioned, well acted love story co-starring one of the all-time greats, Paul Newman. And good ol' Paul would be worth watching in a tooth-pulling contest. While Newman is not the main focus of this movie, the two leads, Kevin Costner and Robin Wright Penn, certainly are. The actors must have found some sort of emotional bond when they were shooting this because while the script is mostly formulaic, their genuine feelings for each other look real. Call it good acting, but once the script calls for them to become smitten, they actually look like they're in love. This relationship is not hokey or off-putting. Luis Mandoki doesn't go for cheap laughs or unrealistic sentiment to draw his audience into the movie. So, it's difficult to stay detached from these attractive characters for long. The plot revolves around the proverbial message in a bottle. Divorced mother Theresa Osborne (Wright Penn) takes a short vacation on the New England coast. While jogging on the beach, she finds a bottle on the shore. She reads the enclosed letter and through her research job at the Chicago Tribune proceeds to track down the author of the note. Her editor (Robbie Coltrane) publishes the letter, which brings about hundreds of letters of input from readers. Theresa is already infatuated with whomever has written the heartbreaking letter and falls for him even more when, through her persistence (and with assistance from co-workers), finds that he has written other beautifully sad letters to his lost beloved. She discovers that the man lives in the Carolinas. Throwing good sense to the wind, she flies down to meet this man. Garret Blake (Costner) is the lonely boat-builder who lost his wife, Catherine, two years before. He has not dealt with the intense pain of her death and neither has her family. He feuds with them, particularly her brother, Johnny (John Savage), about who should keep her paintings and other precious things. Also, Garret lives with Dodge (Newman), his formerly alcoholic, yet caring, father. Theresa meets Garret and they begin a relationship almost immediately. Perhaps all this happens a little quickly, but the movie is only two hours long, after all! They fall in love, but he hasn't gotten over the loss of his wife. That's the premise of "Message In A Bottle". To give away much more would be to give away TOO much. While not a monumental romantic movie, this picture was nicely shot (with a tastefully done bedroom scene) and the actors are easy on the eyes. Wright Penn is beautiful and believable, Costner is deliberately aloof (yet likable anyway), and the legendary Newman is fine as the imperfect father. Costner and Newman make a great father-son team and they actually look alike. Wright Penn and Costner are well-cast (with that great chemistry) and they both show their emotions well. This film pulls no punches. It has few surprises. This is about dealing with intense pain and grief, letting go and moving on. While it's formulaic and the romance blossoms a little too perfectly, the acting is just right. Costner usually gets slammed for his self-indulgence and vanity, but he doesn't even appear until the 20-minute mark in this movie. Plus, this picture doesn't revolve around just him, anyway. It's wonderful to see the magnetic Robin Wright Penn (who picks projects carefully) and especially delightful to see Newman. As a three-part package, they're as honest as the movie they're in. So, bring along a couple boxes of tissues and watch '99s first good love story. Just be careful who you bring along. First dates beware, but lovers enjoy.
USELESS TRIVIA--Unrewarded? If (and it's a big if) Paul Newman receives an Oscar nomination for this supporting role, it would be only his 2nd nomination of the 90s and only his 5th in 20 years!
This film gets a 7/10.

The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


package code: (ECA001BT)
This Price Not Valid For Eid Time, Christmas Time, Puja Time , 15th December to 10th January New Year , Any Special Holiday
Per
Person : 5,900/-BDT ( 12 Months Installment ) ( Selected 5 Bank credit card holder only)
SCB - EBL - City American -Brac - Lanka Bangla
----------------------------------------------------------------------------------------------------
Land Package : 32,000/- BDT + Air Ticket Price : 23,500/-
BDT = Total 63,500/- BDT
Special Note:
This Package is design with Lowest
Economy Class Air fare (Depends on availability).
AirTicket Price Can Change Any Time
Any day private tour. (Option 1)
DAY 1. CAIRO :
Arrival in Cairo international airport, Meet & Assist at the airport and After going through Immigration, Baggage Claim and Customs, Transfer to the hotel dinner And Overnight.
DAY 2. FULL DAY CAIRO TOUR :
HIGHLIGHTS OF THE DAY
Pyramids of Choeps, Chepren and Mycerious.
The great pyramids are the only ones surviving of the seven wonders of the ancient world. They are Egypt's most visited monuments and among the worlds greatest tourist attractions.
The Ancient Egyptians built the pyramids as tombs
to preserve the bodies of their dead kings, especially that they believed in
resurrection and immortality, The Pyramids of Giza lie at the western edge of
Greater Cairo, about 10 kms from downtown, and comprise:
The Great Pyramid
The most famous structure in the world and the only surviving of the Seven
Wonders of the Ancient World. It was built by King Khufu (Cheops) of the IV
Dynasty around 2650 BC. lts height now is 137 m (original height: 146 m). Almost
2.5 million blocks of stone were put into building this pyramid. All this,
however, dwindles when compared to the precision and astounding ability of the
ancient Egyptian in building this pyramid. Close to the eastern flank of the
Pyramid of Khufu lie three small pyramids dedicated either to his wives or
family members.
The Second Pyramid
Built by Khafre (Chephren), south-west of his father's (Khufu's) pyramid though
lower in height: 136 m. It still retains, on some of its upper parts, the
remains of the limestone that had once covered it all. At the base, it measures
215.5 m square. lts interior is simple, with two entrances on the north side.
The visitor can also still see the remains of Khafre's mortuary temple, the
Temple of the Valley, and rising causeway. These temples witnessed the
religious rites during the embalming of the body.
The Third Pyramid
Built by Menkaure (Mycerinus), south-west of the Great and Second Pyramids. It
is much smaller than either one (62 m high). It is distinguished by the fact
that the lower part of its sides still retain their granite slab coverings.
On the way to the Temple of the Valley, lies the large statue of the Sphinx. The Sphinx is carved from a single piece of stone. One of most famous monuments in the world, it is indeed a legendary statue for it has the body of lion and the face of a man. lt is 70 m long and 20 m high. The face of the Sphinx closely resembles that of King Kephren.
THE PERFUMERY
Since time immemorial the Egyptians have been extracting essential oils for essences. Here you have a chance to experience the aromas like, 'The secrets of the desert,' 'The lotus' and all popular international designer perfumes and colognes.
THE PAPYRUS
The papyrus was first made in ancient Egypt- learn how to manufacture this paper using papyrus reeds. And you have an opportunity to buy some hand painted papyrus.
Lunch at local restaurant.
· EGYPTIAN MUSEUM
Called the museum of the Egyptian antiquities, it is one of the greatest museums you will ever see, housing an unrivalled collection of antiquities reaching back 5000years.
DAY 3. CAIRO-ALEXANDRIA-CAIRO :
Breakfast at the hotel. Transfer to Alexandria by road (2.5 hrs approx)
Highlights of the day:
· THE CATACOMBS OF KOM EL SHOUKAFA.
Kom El Shoukafa is an underground wonder world of ornate carvings and paintings and a mixture of Roman and Egyptian designs. It is the largest Roman Funerary complex in Egypt. And dates from the second century A.D. This warren of tombs, on three levels, also contains the Triclinium, where relatives used to sit on stone benches to feast the dead, and a central tomb with reliefs of bearded serpents. Inside are 2nd century A.D. statues of Sobek and Anubis wearing roman armor.
· CITADEL OF FORT QAITBEY
This citadel is the further most edifices on the harbors arm. The fort is on the original site of the Pharos, Alexandria’s ancient lighthouse, built in 279 BC to a height of 12 meters and topped with the statue of Poseidon. Although Pharos was restored at various times it had finally crumbled by the time the original fort was built here, in the 1480’s. This magnificent structure houses Fort Qait Beys naval museum.
· THE ROMAN THEATER.
Discovered in 1964, after 30 years of excavation, this well preserved ancient Roman Theatre with the marble seats, galleries and sections of mosaic flooring, was probably a roofed theatre used for musical performances and based on the inscriptions carved on the seats, wrestling contests. The theatre had a capacity of 700 to 800 seats and in Ptolemaic times it was park of Pan, a pleasure garden surrounded by Roman villas and baths.
Return to Cairo. Evening at leisure
DAY
4. FULL DAY CAIRO TOUR :
Breakfast at the hotel. Proceed to the full day tour for the day
HIGHLIGHTS OF THE DAY
COPTIC CAIRO
THE HANGING CHURCH (AL MUALLAQA)
The hanging church was built in the 4th century over southern gate of the fortress of Babylon .Dedicated to Virgin Mary, its treasures includes a 14 th century wall painting of the Nativity.
CHURCH OF ST.SERGIUS (ABU SERGA)
A 5 th century basilica built over crypt where the Holy Family is believed to have stayed during their flight into Egypt.
CHURCH OF ST.MERCURIUS (ABU SEFEIN)
It boasts a unique collection of Coptic art including 175 icons that depict scenes from the old and new testaments, wall paintings, etching and stained glass.
GREEK ORTHODOX CHURCH OF MARI GIRGIS
Built on one of the towers of Babylon Fortress, this basilica is round in structure with domed roof.
Lunch at local restaurant.
Return to the hotel for dinner and overnight.
 Just a few miles from the center of Cairo is a time machine waiting to take you on a fantastic journey to the days of the Pharaohs, a time brought to life by an incredible group of actors and actresses, faithful and exact reproductions of buildings, clothing, and lifestyles At the pharaonick Village, visitors sail on comfortable motorized barges down a network of canals and view incredibly accurate tableaux of the recreation of ancient Egyptian life. Over a hundred actors and actresses perform all the daily activities and arts of the ancient Egyptians, including agriculture, pottery, sculpture, weaving, and much more. Everyone that would have existed in an ancient Egyptian city is here in the modern recreation, from pharaohs to fishermen, from potters to priests. Because of this attention to detail, the pharaonick Village is more than education and entertainment; it is a vital resource in the preservation of our knowledge of the ancient world.
In the evening there is Nile cruise Dinner, which lasts for 2 hours, sailing on the Nile with Folkloric Shows and Belly Dancers. At the end of this cruise you will be driven back to your hotel
DAY 5. Departure :
Your final day starts with breakfast at the hotel followed by check-out. You will then be transferred to the airport for your final departure.
End of Program
- Visa Entry for Egypt.
- International Flights
- Personal items.
- Tipping.
- Any other items not mentioned.
- Any Optional tours.
- Any meals not stated on the itinerary.
Ø This Package is design with Lowest Economy Class Air fare (Depends on availability).
Ø AirTicket Price Can Change Any Time
Ø This Price Not Valid For Eid Time, christmas Time, Puja Time , 15th December to 10th January New Year , Any Special Holiday


The Climate Crisis on Oceans
It’s undeniable that global warming is a growing concern of this century. Its implicit effects have grown substantially affecting multiple parts of the earth. A particular vulnerable part are our oceans, which compromise 2/3’s of your planet. In this blog post I want to explore the list of ways that the ocean is primarily going to be affected by the impacts of climate change. If you want to read more about the science about how our planet is warming due to green house gases this is a great read. The rest of this blog post assumes that you have the basic background for how climate change is occurring.
1. Ocen Acidification
Ocean acidification is one of the largest issues the planet is going to face as a result of climate change.
Ocean Acidification: the ongoing decrease in the pH of the Earth's oceans, caused by the uptake of carbon dioxide (CO2) from the atmosphere.
The way this happens is the rise of CO2 in the atmosphere is being more and more absorbed by the atmosphere through natural processes. After this CO2 is absorbed, the CO2 reacts to form carbonic acid which thus decreases the pH of the ocean. The ocean is a well oiled machine and this increase in acidity is messing with a lot of the well balanced ecosystem’s that the ocean has put in place. Some ramifications such as marine species that form shells made of carbonate can’t do that anymore due to the pH, more limited carbon supplies, and greater difficulty to sustain coral life
2. Sea Level
One of the more obvious ramifications of climate change is going to be the rise of sea level. The increase in Earth’s temperature is going to cause the temperatures at the poles to rise, thus the gallons of water that are frozen in land glaciers are going to melt and these gallons of water are going to pour into the ocean. Thus, this increase in input into the ocean is going to cause the sea level to rise. This increase in sea level has major consequences especially to major costal cities. These cities will see major flooding and a lot of disruptment in human life.
Conclusion
There are many other consequences of climate change that I did not highlight in this article, but these are the two big ones that need to come to light.


Upper one is root-level app bar.
Below one is a block-level app bar with display-level="block" and class="mce-light"


Change plan for ${subscription.id}
${plan.id}
Success! Your subscription has been updated
Error! You must add payment information first
Error! There are no published plans to change to
Error! An invalid plan was selected
Error! An invalid plan was selected
Error! An error occurred updating your subscription


Running the application
Broker application can be used in commmand line or GUI mode. The command line
mode is headless (ie no GUI is displayed). The application will dump booking
and execution data to stdout in both modes. You may want to capture this data
and errors to files by redirecting stdout and stderr.
Command Line Mode
Run the broker from the command line with the following parameters
java -Dactors.corePoolSize=16 -cp broker.jar mcgill.codejam.exchange.broker.cli.BrokerCLI exchange_url broker_context_path broker_port number_threads data_file_path
Make sure to include the java runtime setting -Dactors.corePoolSize=16
You must supply five command line parameters
| Parameter | Description |
| exchange_url | The URL at which your exchange is listening for orders. Example: http://localhost:80/exchange/endpoint |
| broker_context_path | The url path that you want the broker to listen. Example: /broker |
| broker_port | The port you want the broker to listen on. Example: 1010 |
| number_threads | Number of threads the broker will use to send orders to your exchange. Example: 5. This option is only used if you specified your orders as "Parallel" in your data file. See section on data files. |
| data_file_path | File path to your data file. Example: c:\TEMP\YYZ.TXT |
The broker will run and book all the orders in the data file. After it has booked it will wait for further commands to be entered from the keyboard. Supported commands
are listed below.
| Command | Description |
| <ENTER> | Will reload the data file and rebook it. |
| :q<ENTER> | Will exit the client. |
GUI Mode
Run the broker from the command line with the following classpath
java -cp broker.jar mcgill.codejam.exchange.broker.ui.BrokerUI
You must fill in the Configuration section with the following settings
| Setting | Description |
| Full URL | The URL at which your exchange is listening for orders. Example: http://localhost:80/exchange/endpoint |
| Context path | The url path that you want the broker to listen. Example: /broker |
| Port | The port you want the broker to listen on. Example: 1010 |
| Threads | Number of threads the broker will use to send orders to your exchange. Example: 5. This option is only used if you specified your orders as "Parallel" in your data file. See section on data files. |
| Orders file | File path to your data file. Example: c:\TEMP\YYZ.TXT |
To book orders to your exchange click the "Book!" button. The UI will update
as the exchange accepts or rejects orders. If the broker cannot connect to
the exchange it will update the "Rejected" check box after trying to send the
order. As order execution messages arrive at the broker you will see them
appear in the "Order executions" and "Unmatched executions" grids. Unmatched
executions are executions that have an order ref id that does not appear in
the "Orders" grid. When the broker receives one or more executions for an
order the Executed check box will be checked for that order. When an order is
only partially filled the Executed check box it will be highlighted in
yellow. Once the order has been completely filled it will be highlighted in
green. If the shares in all the execution messages for an order sum up to a
number greater than the quantity of shares in the order the order will be
highlighted in red.
Data File Format
Each order is put on a separate line. The elements of the order are
Buy/Sell [Stock Quantity] [Stock Symbol] @ [Price] #[Telephone Number] TW
The twilio indicator TW is optional. If it is present then your exchange should
send an SMS to the phone number for trade executions. If the orders are wrapped in the
Parallel{} construct then the orders will be sent in parallel using the thread pool.
If no Parallel() construct is present the orders are sent in a serial manner.
Examples of the data file format are given below.
Example 1
Buy 12 MS @ 12.34 #+15145551212
Sell 12 MS @ 12.34 #+19176395561 TW
Example 2
Parallel {
Buy 12 MS @ 12.34 #+15145551211
Sell 12 MS @ 12.34 #+15145551212
}
Example 3
Parallel(
Sell 456 Pc @ 876.32 #+15145551212
Buy 456 Pd @ 876.32 #+15145551213
)


from herschelhelp_internal import git_version
print("This notebook was run with herschelhelp_internal version: \n{}".format(git_version()))
%matplotlib inline
#%config InlineBackend.figure_format = 'svg'
import matplotlib.pyplot as plt
plt.rc('figure', figsize=(10, 6))
plt.style.use('ggplot')
import locale
locale.setlocale(locale.LC_ALL, 'en_GB')
import os
import time
import itertools
from astropy.coordinates import SkyCoord
from astropy.table import Table
from astropy import units as u
from astropy import visualization as vis
import numpy as np
from matplotlib_venn import venn2, venn3
from herschelhelp_internal.masterlist import nb_compare_mags, nb_ccplots, nb_histograms, find_last_ml_suffix, quick_checks
OUT_DIR = os.environ.get('OUT_DIR', "./data")
SUFFIX = find_last_ml_suffix()
#SUFFIX = "20170711"
master_catalogue_filename = "master_catalogue_elais-s1_{}.fits".format(SUFFIX)
master_catalogue = Table.read("{}/{}".format(OUT_DIR, master_catalogue_filename))
print("Diagnostics done using: {}".format(master_catalogue_filename))
quick_checks(master_catalogue).show_in_notebook()
flag_obs = master_catalogue['flag_optnir_obs']
flag_det = master_catalogue['flag_optnir_det']
venn3(
[
np.sum(flag_obs == 4),
np.sum(flag_obs == 2),
np.sum(flag_obs == 6),
np.sum(flag_obs == 1),
np.sum(flag_obs == 5),
np.sum(flag_obs == 3),
np.sum(flag_obs == 7)
],
set_labels=('Optical', 'near-IR', 'mid-IR'),
subset_label_formatter=lambda x: "{}%".format(int(100*x/len(flag_obs)))
)
plt.title("Wavelength domain observations");
venn3(
[
np.sum(flag_det[flag_obs == 7] == 4),
np.sum(flag_det[flag_obs == 7] == 2),
np.sum(flag_det[flag_obs == 7] == 6),
np.sum(flag_det[flag_obs == 7] == 1),
np.sum(flag_det[flag_obs == 7] == 5),
np.sum(flag_det[flag_obs == 7] == 3),
np.sum(flag_det[flag_obs == 7] == 7)
],
set_labels=('Optical', 'near-IR', 'mid-IR'),
subset_label_formatter=lambda x: "{}%".format(int(100*x/np.sum(flag_det != 0)))
)
plt.title("Detection of the {} sources detected\n in any wavelength domains "
"(among {} sources)".format(
locale.format('%d', np.sum(flag_det != 0), grouping=True),
locale.format('%d', len(flag_det), grouping=True)));
The master list if composed of several catalogues containing magnitudes in similar filters on different instruments. We are comparing the magnitudes in these corresponding filters.
u_bands = []
g_bands = [ "DECam g"]
r_bands = ["VOICE r", "DECam r"]
i_bands = [ "DECam i"]
z_bands = [ "DECam z"]
y_bands = ["VISTA y", "DECam y"]
j_bands = ["VISTA j"]
h_bands = ["VISTA h"]
k_bands = ["VISTA k"]
We compare the histograms of the total aperture magnitudes of similar bands.
for bands in [g_bands, r_bands, i_bands, z_bands, y_bands, j_bands, h_bands, k_bands]:
colnames = ["m_{}".format(band.replace(" ", "_").lower()) for band in bands]
nb_histograms(master_catalogue, colnames, bands)
We compare one to one each magnitude in similar bands.
for band_of_a_kind in [r_bands, y_bands, j_bands, h_bands, k_bands]:
for band1, band2 in itertools.combinations(band_of_a_kind, 2):
basecol1, basecol2 = band1.replace(" ", "_").lower(), band2.replace(" ", "_").lower()
col1, col2 = "m_ap_{}".format(basecol1), "m_ap_{}".format(basecol2)
nb_compare_mags(master_catalogue[col1], master_catalogue[col2],
labels=("{} (aperture)".format(band1), "{} (aperture)".format(band2)))
col1, col2 = "m_{}".format(basecol1), "m_{}".format(basecol2)
nb_compare_mags(master_catalogue[col1], master_catalogue[col2],
labels=("{} (total)".format(band1), "{} (total)".format(band2)))
Cross-match the master list to 2MASS magnitudes.
master_catalogue_coords = SkyCoord(master_catalogue['ra'], master_catalogue['dec'])
The catalogue is cross-matched to 2MASS-PSC withing 0.2 arcsecond. We compare the UKIDSS total J and K magnitudes to those from 2MASS.
The 2MASS magnitudes are “Vega-like” and we have to convert them to AB magnitudes using the zero points provided on this page:
| Band | Fν - 0 mag (Jy) |
|---|---|
| J | 1594 |
| H | 1024 |
| Ks | 666.7 |
In addition, UKIDSS uses a K band whereas 2MASS uses a Ks (“short”) band, this page give a correction to convert the K band in a Ks band with the formula:
$$K_{s(2MASS)} = K_{UKIRT} + 0.003 + 0.004 * (J−K)_{UKIRT}$$# The AB zero point is 3631 Jy
j_2mass_to_ab = 2.5 * np.log10(3631/1595)
k_2mass_to_ab = 2.5 * np.log10(3631/666.7)
twomass = Table.read("../../dmu0/dmu0_2MASS-point-sources/data/2MASS-PSC_ELAIS-S1.fits")
twomass_coords = SkyCoord(twomass['raj2000'], twomass['dej2000'])
idx, d2d, _ = twomass_coords.match_to_catalog_sky(master_catalogue_coords)
mask = (d2d < 0.2 * u.arcsec)
twomass = twomass[mask]
ml_twomass_idx = idx[mask]
nb_compare_mags(twomass['jmag'] + j_2mass_to_ab, master_catalogue['m_vista_j'][ml_twomass_idx],
labels=("2MASS J", "VISTA J (total)"))
From here, we are only comparing sources with a signal to noise ratio above 3, i.e. roughly we a magnitude error below 0.3.
To make it easier, we are setting to NaN in the catalogue the magnitudes associated with an error above 0.3 so we can't use these magnitudes after the next cell.
for error_column in [_ for _ in master_catalogue.colnames if _.startswith('merr_')]:
column = error_column.replace("merr", "m")
keep_mask = np.isfinite(master_catalogue[error_column])
keep_mask[keep_mask] &= master_catalogue[keep_mask][error_column] <= 0.3
master_catalogue[column][~keep_mask] = np.nan
nb_ccplots(
master_catalogue['m_voice_r'],
master_catalogue['m_ap_voice_r'] - master_catalogue['m_voice_r'],
"r total magnitude (VOICE)", "r aperture mag - total mag (VOICE)",
master_catalogue["stellarity"],
invert_x=True
)
nb_ccplots(
master_catalogue['m_voice_b99'] - master_catalogue['m_voice_r'],
master_catalogue['m_vista_j'] - master_catalogue['m_vista_k'],
"b99 - r (VOICE)", "J - K (VISTA)",
master_catalogue["stellarity"]
)
nb_ccplots(
master_catalogue['m_voice_r'] - master_catalogue['m_irac1'],
master_catalogue['m_voice_b99'] - master_catalogue['m_voice_v'],
"VOICE r - IRAC1", "b99 - v (VOICE)",
master_catalogue["stellarity"]
)
nb_ccplots(
master_catalogue['m_vista_j'] - master_catalogue['m_vista_k'],
master_catalogue['m_vista_h'] - master_catalogue['m_vista_y'],
"J - Ks (VHS)", "H - Y (VIDEO)",
master_catalogue["stellarity"]
)


Find User
Create Nudge
Sent
Received
Groups
Find User
Home Feed
Create Nudge
Sent
Received
Groups
Find User
Search by:
Username
Phone Number
Email Address
Search


Reports packages that were not downloaded via
pub get
or updated via
pub upgrade
after editing the
pubspec.yaml
file.


This scenario demonstrates the most basic binding - programmtically hooking up change notifications on a data object that causes a function to execute. The bindable object has already been created, you may use the input fields below to change their values. (Tab between the text boxes to update the display.)
The current value of X is:
The current value of Y is:


{% extends 'layout.html' %} {% block title %}Fyle Accounting Integrations - Employee List{% endblock %} {% block body_content %}
| Full Name | Employee Email | Employee Code | Business Unit | Department | Title | Code 1 | Code 2 | Code 3 | Disabled |
|---|---|---|---|---|---|---|---|---|---|
| {{ employee.full_name }} | {{ employee.employee_email }} | {{ employee.employee_code }} | {{ employee.business_unit }} | {{ employee.department }} | {{ employee.title }} | {{ employee.code1|default_if_none:"" }} | {{ employee.code2|default_if_none:"" }} | {{ employee.code3|default_if_none:"" }} | {{ employee.disabled }} |


Overview
Java
The main prerequisite to run the Eclipse Embedded CDT is Java. Generally Java is not available by default on most platforms, and requires a separate installation.
Other tools
Here is a list of other tools/packages that need to be installed before starting Eclipse.
- node/npm/xpm - although not mandatory, but highly recommended, the second prerequisite is xpm (the xPack Package Manager), which is a Node.js portable application;
- Windows Build Tools - to build projects, on Windows it is necessary
to install
make
, available from the xPack Windows Build Tools; - Arm toolchain - to build Arm projects, an Arm toolchain like the xPack GNU Arm Embedded GCC is required;
- RISC-V toolchain - similarly, for RISC-V projects, a RISC-V toolchain like the xPack GNU RISC-V Embedded GCC is required;
- SEGGER J-Link - to debug projects, a JTAG probe is necessary together with the software to access it, for example the SEGGER J-Link software;
- OpenOCD - for some boards, xPack OpenOCD might also be useful;
- QEMU Arm - to run debug sessions without actual hardware, the xPack QEMU Arm emulator is necessary (the blinky tutorial mandates it).
Install Java
The following section covers the common Windows/macOS/Linux platforms; for a wider range of platforms, see the Alternate solutions below.
Current Windows distributions do not include Java.
The recommended package is the latest version from the official Oracle OpenJDK page.
Follow the Download link in the Oracle page, which currently points to jdk.java.net/15.
In the Builds section, download the Windows/x64 .zip
file.
Create a new folder
mkdir %APPDATA%\Oracle
And extract the archive content into ...\AppData\Roaming\Oracle\jdk-15
.
To set the path, in a cmd.exe terminal, issue the following:
set Path=%APPDATA%\Oracle\jdk-15\bin;%Path%
setx Path "%APPDATA%\Oracle\jdk-15\bin;%Path%"
Check version:
java --version
It is possible to install multiple versions on the same system, and chose which one to use by controlling the Path.
The current macOS releases no longer pack Java.
The recommended package is the latest version from the official Oracle OpenJDK page.
Follow the Download link in the Oracle page, which currently points to jdk.java.net/15.
In the Builds section, download the macOS/x64 .tar.gz file.
cd ~/Downloads
xattr -d com.apple.quarantine openjdk-15_osx-x64_bin.tar.gz
tar xf openjdk-15_osx-x64_bin.tar.gz
sudo mv jdk-15.jdk/ /Library/Java/JavaVirtualMachines/
Check version:
java --version
On recent macOS systems, this might fail or trigger a security message. To overcome this, go to System Preferences → Security & Privacy → Allow.
On macOS 10.15 the system automatically identifies the latest version
installed in /Library/Java/JavaVirtualMachines/
and somehow
links /usr/bin/java
to it.
% which java
/usr/bin/java
% ls -l /usr/bin/java
lrwxr-xr-x 1 root wheel 74 Jan 2 2020 /usr/bin/java -> /System/Library/Frameworks/JavaVM.framework/Versions/Current/Commands/java
How exactly it gets from here to the actual location is a bit of Apple magic.
Since it is possible to install multiple version on the same system,
if you want to override this mechanism and use a different version, try
to configure the user path via launchctl
:
sudo launchctl config user path /Library/Java/JavaVirtualMachines/jdk-15.jdk/Contents/Home/bin/:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
sudo reboot
As shown above, for this configuration to become effective, it is necessary to reboot.
To check if the new path was configured properly:
launchctl getenv PATH
Please note that the above command configures only the path for the GUI
applications. For shell usage, it is necessary to also set the PATH
environment variable in the shell startup files (like .zprofile
):
export PATH=/Library/Java/JavaVirtualMachines/jdk-15.jdk/Contents/Home/bin/:${PATH}
On most modern Linux distributions, OpenJDK is available as a package.
To check if it is already installed, ask the version:
java -version
If it is not installed, or it is not at least Java 11, install it via the package manager.
For example on Ubuntu:
sudo apt install --yes openjdk-15-jdk
Or on CentOS:
sudo yum -y install java-15-openjdk
Check your system for the available package names and versions.
However, if you cannot find at least JDK 11, install the Oracle OpenJDK.
The recommended package is the latest version from the official Oracle OpenJDK page.
Follow the Download link in the Oracle page, which currently points to jdk.java.net/15.
In the Builds section, download the Linux/x64 .tar.gz file.
mkdir -p ${HOME}/opt
cd ${HOME}/opt
tar xf ~/Downloads/openjdk-15_linux-x64_bin.tar.gz
Then add the location to the user PATH:
export PATH=${HOME}/opt/jdk-15/bin/:${PATH}
Check version:
java --version
If your Windows Manager allows to start Eclipse with clicks in the file manager without using a shell, you might need to set the GUI path in a way specific to the window manager.
On some distributions (like Ubuntu) this can be achieved via ~/.xsessionrc
,
sourced from one of the files in /etc/X11/Xsession.d/
.
It is possible to install multiple versions on the same system, and chose which one to use by controlling the PATH.
It is also possible to edit eclipse.ini
and add a -vm
option pointing to the Java bin path; be sure this
option is placed before -vmargs
, which should be the last one:
--launcher.defaultAction
openFile
-vm
/home/ilg/opt/jdk-15/bin/
-vmargs
-Dosgi.requiredJavaVersion=11
-XX:MaxPermSize=256m
-Xms256m
-Xmx2048m
Alternate Java distributions
For those who prefer alternate solutions, the second recommendation goes to AdoptOpenJDK which provides prebuilt OpenJDK binaries for an even wider range of platforms.
Install node/npm/xpm
The next step is to install the xPack tools.
For full details, please follow the steps in the separate install pages:
For convenience for those who already know what this means, here is a brief.
For macOS and GNU/Linux, use nvm (for Windows use the .msi, as explained in the node install page):
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/master/install.sh | bash
exit
In a new terminal, to benefit from the environment variables added by the script:
nvm install --lts node
nvm use node
node --version
nvm install-latest-npm
npm --version
Install xpm:
npm install --global xpm@latest
On Windows, install make and the rest of the build tools:
xpm install --global @xpack-dev-tools/windows-build-tools@latest
Install the toolchain and the other tools; don’t skip qemu, since it is used by the blinky tutorial; openocd may also be useful to run debug sessions; the riscv toolchain is necessary only for RISC-V projects.
xpm install --global @xpack-dev-tools/arm-none-eabi-gcc@latest
xpm install --global @xpack-dev-tools/qemu-arm@latest
xpm install --global @xpack-dev-tools/openocd@latest
xpm install --global @xpack-dev-tools/riscv-none-embed-gcc@latest
All xPacks are installed in a central folder in the user home; check the xpm output for the actual location.
Miscellaneous
Windows Build Tools
Briefly mentioned before as a supplementary step after installing xpm, running builds on Windows requires tools that Microsoft does not include in the base distribution and need to be installed separately.
For convenience, these tools were packed as the xPack Windows Build Tools and can be easily installed via xpm.
Discontinued 32-bit support
All recent Eclipses are 64-bit and require 64-bit platforms; using older 32-bit systems is still possible with older Eclipse versions, but is discouraged.
Eclipse Neon and up to Eclipse 2020-09
Starting with version 6.0.0, the Embedded CDT plug-ins are based on the API defined in CDT 10.0.0 and require at least Eclipse 2020-09.
The previous releases, up to 5.2.1, were based on CDT 9.2.1, which was published with Eclipse 4.6 Neon, released in 2016.
If, for any reason, you need to use an older Eclipse (like, for example, for running on a 32-bit system), be sure it includes at least CDT 9.2.1.
Comments on the content of this page that might be useful for other readers are welcomed here. For question and general support, please use the project forums.


{% extends "tracker/base.html" %} {% load static %} {% block title %} General Conference - Login {% endblock %} {% block sub_navigation %}
You must be logged in to access this feature.


I thought meditation helps people to control feelings and emotions by clearing their mind and enhance concentration.
Meditation is mental training that can be done by focusing on breathing and gaining attention. It enhances mental health and happiness. It gives detailed instruction about the right posture which needs to be both alert and relaxed and how to meditate properly. That was different what I thought and was interesting.
I found how to deal with distractions are pretty interesting because When I meditate I always tried hard to get rid of distractions. but it said 'experience without judging' and 'gently inviting it to stop distracting'. Also I liked 'grandmother mind'and becoming friend with myself and I thought it is what I need sometimes.
It was surprising that meditation even speeds up people's skin recovery.


Welcome!
Github api and Pipedrive api implementation
Set key
Last used
Get gists / Create deals
List of Gists and details
updated gist:


Daring escape in Hong Kong | US changes Israeli settlement policy: WATCH the top world news videos for today
Daring rope escape in Hong Kong
Dozens of Hong Kong pro-democracy protesters dramatically escape a two-day police siege at a university campus late Monday by shimmying down ropes from a bridge to waiting motorbikes.
US softens position on Israeli settlements
The US on Monday effectively backed Israel's right to build Jewish settlements on the occupied West Bank by abandoning its four-decade-old position that they were "inconsistent with international law".
Warren vows to protect tenants from bad landlords
Democratic presidential hopeful Elizabeth Warren on Monday vowed to protect the country's 43 million renter households, releasing a plan that would help tenants fight eviction, afford their homes and retain lawyers in housing courts.
Protesters gather in Italy Square in Santiago
Protesters gather in Italy Square in Santiago, for the fifth consecutive week of demonstrations that have rocked Chile.
Driver who used SUV to shield pedestrians from speeding car says he doesn't feel like a hero
The City of Montreal is honouring a man who is being hailed as a hero after he used his SUV to shield pedestrians from a speeding car. Mayor Valerie Plante praised Erick Marciano's act of courage as she presented him with a certificate of honour.