Process Control Block

Process Control Block (PCB, also called Task Controlling Block, Task Struct, or Switchframe) is a data structure in the operating system kernel containing the information needed to manage a particular process.

Process state. The state may be new, ready, running, waiting, halted, and so on.

Program counter. The counter indicates the address of the next instruction to be executed for this process.

CPU registers. They include accumulators, index registers, stack pointers, and general-purpose registers, plus any condition-code information. Along with the program counter, this state information must be saved when an interrupt occurs, to allow the process to be continued correctly afterward.

CPU-scheduling information. This information includes a process priority, pointers to scheduling queues, and any other scheduling parameters.

Memory-management information. This information may include such information as the value of the base and limit registers, the page tables, or the segment tables, depending on the memory system used by the operating system.

Accounting information. This information includes the amount of CPU and real time used, time limits, account numbers, job or process numbers, and so on.

I/O status information. This information includes the list of I/O devices allocated to the process, a list of open files, and so on.

Context Switch

A context switch (also sometimes referred to as a process switch or a task switch) is the switching of the CPU (central processing unit) from one process or thread to another.

A context is the contents of a CPU’s registers and program counter at any point in time.

A program counter is a specialized register that indicates the position of the CPU in its instruction sequence and which holds either the address of the instruction being executed or the address of the next instruction to be executed, depending on the specific system.

Context switching can be described in slightly more detail as the kernel (i.e., the core of the operating system) performing the following activities with regard to processes (including threads) on the CPU:

1. suspending the progression of one process and storing the CPU’s state (i.e., the context) for that process somewhere in memory,

2. retrieving the context of the next process from memory and restoring it in the CPU’s registers and

3. returning to the location indicated by the program counter (i.e., returning to the line of code at which the process was interrupted) in order to resume the process.

When to switch?

Context switches can occur only in kernel mode.

Multitasking 1.)Preemptive schedulers often configure a timer interrupt to fire when a process exceeds its time slice. 2.)This context switch can be triggered by the process making itself unrunnable, such as by waiting for an I/O or synchronization operation to complete.

Interrupt handling 1.) Hardware interrupt

User and kernel mode switching may cause context switch.

Multithread programing

Benifits 1.) Responsiveness 2.)Resource sharing 3.) Economy 4.)Scalability

Multicore Programming

Concerns 1.) Dividing activities 2.)Balance Data splitting 3.)Data dependency 4.)Testing and debugging

Multithread Model

• Many-to-one model
• One-to-one model

The nptl(native posix thread library) implementation only uses a 1:1 thread model. The scheduler handles every thread as if it were a process. Therefore only the supported scope is PTHREAD_SCOPE_SYSTEM(Plesae see on Pthread Scheduling label). The default scheduling policy is SCHED_OTHER, which is the default Linux scheduler. The nptl implementation can utilize multiple CPUs.

• Many-to-many model
• Green thread

On multi-CPU machines, native threads can run more than one thread simultaneously by assigning different threads to different CPUs. Green threads run on only one CPU.

Green threads, the threads provided by the JVM, run at the user level, meaning that the JVM creates and schedules the threads itself. Therefore, the operating system kernel doesn’t create or schedule them. Instead, the underlying OS sees the JVM only as one thread.

• Light weight process(LWP) In the traditional meaning of the term, as used in Unix System V and Solaris, a LWP runs in user space on top of a single kernel thread and shares its address space and system resources with other LWPs within the same process.

Pthread Scheduling

There are two possible contention scopes. PTHREAD_SCOPE_SYSTEM and PTHREAD_SCOPE_PROCESS. They can be set with pthread_attr_setscope(). The scope of a thread can only be specified before the thread is created.

• PTHREAD_SCOPE_SYSTEM

A thread that has a scope of PTHREAD_SCOPE_SYSTEM will content with other processes and other PTHREAD_SCOPE_SYSTEM threads for the CPU.

• PTHREAD_SCOPE_PROCESS

All threads of a process that have a scope of PTHREAD_SCOPE_PROCESS will be grouped together and this group of threads contents for the CPU. If there is a process with 4 PTHREAD_SCOPE_PROCESS threads and 4 PTHREAD_SCOPE_SYSTEM threds, then each of the PTHREAD_SCOPE_SYSTEM threads will get a fifth of the CPU and the other 4 PTHREAD_SCOPE_PROCESS threads will share the remaing fifth of the CPU. How the PTHREAD_SCOPE_PROCESS threads share their fifth of the CPU among themselves is determined by the scheduling policy and the thread’s priority.

Process Creation

When a process creates a new process, two possibilities exist in terms of execution:

1. The parent continues to execute concurrently with its children.
2. The parent waits until some or all of its children have terminated.

There are also two possibilities in terms of the address space of the new process:

1. The child process is a duplicate of the parent process (it has the same program and data as the parent).
2. The child process has a new program loaded into it.

For example, if clone() is passed the flags CLONE FS, CLONE VM, CLONE SIGHAND, and CLONE FILES, the parent and child tasks will share the same file-system information (such as the current working directory), the same memory space, the same signal handlers, and the same set of open files.

However, if none of these flags is set when clone() is invoked, no sharing takes place, resulting in functionality similar to that provided by the fork() system call.

There is audit trial requirement that need to be captured into log table these day. But we suffer from the limited function provided by Sybase ASE DB in order to achieve our goals. SybaseASE 12.5 does not support neither analytic function nor row number column, and therefore we have to implement cross comparison by ourselves via basic semantics.

1
2
3
4
5
6
7
8
9
10
11
12
13

--create rownum column
select rownum = identity(10), * from #temp_table from table where 1=2

insert into #temp_table
select * from table where pid = @pid
insert into #temp_table
select * from table_history where pid = @pid order by audit_update_date desc

--use self-join to match the cross rows
select a.rownum,
      case when a.col1 = b.col1 then 'equal' else 'inequal' end
from #temp_table a left out join #temp_table b on ( a.pid = b.pid and (a.rownum + 1) = b.rownum )
where ...

In contrast, we also provide oracle version of implementation.

In practice, we will meet the requirement to rotate the table including convert cols to rows, convert rows to cols. In this session, I’ll produce the solution in common method as well as db-specified features.

Convert columns to rows

1
2
3
4
5
6
7
8
9
10

--common solution
select * from (
  select id, 'col_1' as col_name, col_1 as col_val
  from table
  union all
  select id, 'col_2' as col_name, col_2 as col_val
  from table
  union all
  ...
) order by id

1
2
3
4
5
6
7

--oracle 11g unpivot query
select *
from table
unpivot (
  col_val for col_name in (col_1 as 'col_1', col_2 as 'col_2')
)
order by id

Concert rows to columns

1
2
3
4
5
6
7

  --common solution
  select id,
      max(case when col_name = 'col_1' then col_val else null end) as col_1,
      max(case when col_name = 'col_2' then col_val else null end) as col_2,
      ...
  from table
  order by id

1
2
3
4
5
6
7
8

  --oracle 11g pivot query
  select *
  from table
  pivot (
      max(col_val) for col_name in ('col_1' as col_1,'col_2' as col_2)
  )
  where ...
  order by id

Excel pivot table

For non-sql approaches, we can use excel pivot table. Excel spreadsheets are a great way to pivot and analyze Oracle data, and tools.

The aim of this post is to review the crucial terms of operating-system and basic interaction of these underlying components.

Before starting with topic, I am going to reveal why I try to read books of OS related at this point. Let me conclude the reasons, first and foremost, various applications in my daily work encounter issues that are associated with LINUX system, such as buffer size, open file limits and unable to create native threads etc. All of these issues point out to the knowledge of OS. Next, Java performance tuning is always based on the operating system concept, like memory management, cpu utilization etc. Furthermore, including all the design concepts are derived from the solution of common issue inside operating system.

Due to these, it is so encouraged to read and go through operating system concept again that I could be inspired and get everything tied. If there are any findings or association with Java, I will make more explanations and comments linked with definitive resource.

1.Storage Device Hierarchy

registers — > cache — > main memory (RAM random access memory) — > electronic disk — > magnetic disk — > optical disk — > magnetic tapes

2.Symmetric Multiprocessing (SMP)

SMP systems are tightly coupled multiprocessor systems with a pool of homogeneous processors running independently, each processor executing different programs and working on different data and with capability of sharing common resources (memory, I/O device, interrupt system and so on) and connected using a system bus or a crossbar.

$uname -a
Linux [nodename] 2.6.18-348.18.l.e15 #1 SMP [date] x86_64 x86_64 GUN/Linux

3.Non-uniform Memory Access (NUMA)

NUMA is a computer memory design used in multiprocessing, where the memory access time depends on the memory location relative to the processor. Under NUMA, a processor can access its own local memory faster than non-local memory (memory local to another processor or memory shared between processors).

NUMA collector enhancements

• The Parallel Scavenger garbage collector has been extended to take advantage of machines with NUMA (Non Uniform Memory Access) architecture. The NUMA-aware allocator can be turned on with the -XX:+UseNUMA flag in conjunction with the selection of the Parallel Scavenger garbage collector. The Parallel Scavenger garbage collector is the default for a server-class machine. The Parallel Scavenger garbage collector can also be turned on explicitly by specifying the -XX:+UseParallelGC option. If you want see the detail, please see oracle official document.

4.Clustering

Clustering can be structured asymmetrically or symmetrically. In asymmetric clustering, one machine is in hot-standby mode while the other is running the applications. The hot-standby host machine does nothing but monitor the active server. If that server fails, the hot-standby host becomes the active server. In symmetric mode, two or more hosts are running applications and are monitoring each other. This mode is obviously more efficient, as it uses all of the available hardware. It does require that more than one application be available to run.

For example in real-world scenario: The secondary EMS server is hot-standby mode. Two Weblogic servers are symmetric mode and load balance.

5.Network

5.1.local area network (LAN)

A local area network (LAN) is a computer network that user interconnects computers in a limited area such as a home, school, computer laboratory, or office building using network media.

5.2.storage-area network(SAN)

SANs are primarily used to enhance storage devices, such as disk arrays, tape libraries, and optical jukeboxes, accessible to servers so that the devices appear like locally attached devices to the operating system.

5.3.wide area network (WAN)

A wide area network (WAN) is a network that covers a broad area (i.e., any telecommunications network that links across metropolitan, regional, or national boundaries) using private or public network transports. WANs are often built using leased lines. WANs can also be built using less costly circuit switching or packet switching methods.

6.Computing Environments

6.1.traditional computing

Batch systems processed jobs in bulk, with predetermined input (from files or other sources of data).

Time-sharing systems used a timer and scheduling algorithms to rapidly cycle processes through the CPU, giving each user a share of the resources. Time-sharing systems are an extension of multiprogramming wherein CPU scheduling algorithms rapidly switch between jobs, thus providing the illusion that all jobs are running concurrently.

6.2client–Server computing (compute or file server system)

A socket is identified by an IP address concatenated with a port number. Servers implementing specific services (such as telnet, FTP, and HTTP) listen to well-known ports (a telnet server listens to port 23; an FTP server listens to port 21; and a Web, or HTTP, server listens to port 80).

The remote procedure calls (RPCs) was designed as a way to abstract the procedure-call mechanism for use between systems with network connections.

Remote method invocation (RMI) is a Java feature similar to RPCs.

6.3.peer-to-peer computing

6.4.web-based computing

7.System Calls

In computing, a system call is how a program requests a service from an operating system’s kernel. System calls provide an essential interface between a process and the operating system. System calls can be grouped roughly into six major categories: process control, file manipulation, device manipulation, information maintenance, communications, and protection.

To monitor and trace the system call within the process, we can use strace command in Linux. Strace is used for debugging and troubleshooting the execution of an executable on Linux environment. It displays the system calls used by the process, and the signals received by the process.

$strace

8.Interprocess Communication

There are two common models of interprocess communication:

8.1.message-passing model

Message passing is useful for exchanging smaller amounts of data, because no conflicts need be avoided.

Message passing may be either blocking or nonblocking— also known as synchronous and asynchronous. 1.)Blocking send 2.)Nonblocking send 3.)Blockingreceive 4.)Nonblocking receive

Whether communication is direct or indirect, messages exchanged by commu- nicating processes reside in a temporary queue. 1.)Zero capacity 2.)Boundedcapacity 3.)Unboundedcapacity

8.2.shared-memory model

In the shared-memory model, processes use shared memory create and shared memory attach system calls to create and gain access to regions of memory owned by other processes.

MarkDown Template

Blockquotes

Header inside blockquote

1. This is the first list item.
2. This is the second list item.

This is nested blockquote.

Here’s some example code:

return shell_exec("echo $input | $markdown_script");

List

Markdown supports ordered (numbered) and unordered (bulleted) lists. Unordered lists use asterisks, pluses, and hyphens — interchangably — as list markers:

• Red
• Green

• Blue

• Bird

• McHale
• Parish

To put a code block within a list item, the code block needs to be indented twice — 8 spaces or two tabs:

• A list item with a code block:

Code Blocks

To produce a code block in Markdown, simply indent every line of the block by at least 4 spaces or 1 tab. For example, given this input:

Horizontal Rules

Links

inline links

This is an example inline link. See my About page for details.

reference links

This is an example reference-style link.

implicit link

I get 10 times more traffic from Google than from Yahoo or MSN.

Emphasis

single asterisks

single underscores

double asterisks

double underscores

unfriggingbelievable

*this text is surrounded by literal asterisks*

Code

Use the printf() function. There is a literal backtick (`) here. Please don’t use any <blink> tags.

Images

Miscellaneous

Automatic link

http://daringfireball.net/projects/markdown/syntax#em address@example.com

Blackslash escapes

\   backslash
`   backtick
*   asterisk
_   underscore
{}  curly braces
[]  square brackets
()  parentheses
#   hash mark
+   plus sign
-   minus sign (hyphen)
.   dot
!   exclamation mark

This is an H6