Shulou(Shulou.com)06/01 Report--

This article introduces the relevant knowledge of "how to use GNU Parallel, a Linux parallel job execution tool". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

GNU Parallel is a shell tool. In order to perform computing tasks in parallel on one or more computers, a computing task can be a shell command or a script that takes each line as input. The usual input is a file list, host list, user list, URL list, or table list; a calculation task can also be a command read from a pipe.

1. Introduction to the usage of parallel Usage:parallel [options] [command [arguments]] command [arguments]] (:: arguments |:: argfile (s)). Cat. | parallel-- pipe [options] [command [arguments]] Common options: followed by parameters: followed by file-j, -- number of jobs parallel tasks-N number of parameters per input-- xargs enters as many parameters as possible on one line-- xapply takes a parameter from each source (or file line)-- header takes the first value in each line of input as the parameter name-m means that each job does not repeat the output "background" (context)-X is the opposite of-m Output "background text"-Q protection command repeatedly-trim lr removes spaces at both ends of parameters, only spaces can be removed, newline characters and tab cannot be removed-keep-order/-k forces output to keep order with parameters-- keep-order/-k--tmpdir/-- results saves files But the latter can be saved structurally-- delay delays the start time of each task-- halt terminates the task-- pipe this parameter allows us to divide the input (stdin) into block-- the block parameter can specify the size of each block 1.1 input source.

The input source for GNU Parallel supports file, command line, and standard input (stdin or pipe).

# Command line single input source [20:41 sxuan@hulab ~] $parallel echo: abcde | tee a.txtabcde# stdin (standard input) as the input source [20:42 sxuan@hulab ~] $cat a.txt | parallel echoabcde# GNU Parallel supports specifying multiple input sources through the command line, and it generates all combinations. This is very easy to use [20:45 sxuan@hulab ~] $parallel echo: A B C:: D E F | tee b.txtA DA EA FB DB EB FC DC EC F# multiple files as input in some cases, and the contents of multiple files will also be combined as above [20:46 sxuan@hulab ~] $parallel-an a.txt-a b.txt echo# stdin (standard input) as one of the file sources, using- The output result is the same as [20:52 sxuan@hulab ~] $cat a.txt above | parallel-a-- a b.txt echo# can be used: instead of-a, followed by multiple file names [20:55 sxuan@hulab ~] $cat a.txt | parallel echo:-b.txt# finally,: and: can be used at the same time The same output will be combined [20:55 sxuan@hulab ~] $parallel echo: ab: b.txt

Of course, if you don't want to combine as above, you can use the-xapply parameter to get a parameter (or a file line) from each source, which is somewhat similar to the function in R and has the function of broadcasting-- if one of the input sources is short in length, its value will be repeated.

[20:57 sxuan@hulab ~] $parallel-- xapply echo:: A B C: D E FA DB EC F [21:04 sxuan@hulab ~] $parallel-- xapply echo:: A B C: D E F G H IA DB EC FA GB HC I1.2 change the parameter delimiter

GNU Parallel can use-- arg-sep and-- arg-file-sep to specify delimiters instead of:: or:, which is especially useful when these two symbols are occupied by other commands.

[21:18 sxuan@hulab ~] $parallel-k-- arg-sep, echo, ab, c d | tee c.txta ca db cb d [21:22 sxuan@hulab ~] $parallel-- xapply-- arg-file-sep, echo, a.txt b.txta A Db An Ec A Fd B De B Ea B Fb C Dc C Ed C F1.3 change the input delimiter

GNU Parallel defaults to a line as a parameter: use\ nas the parameter delimiter. You can use-d to change:

[21:25 sxuan@hulab ~] $parallel-d b echo: a.txtacde1.4 ends early and skips empty lines

GNU Parallel supports specifying a value as the closing flag through the-E parameter:

[21:26 sxuan@hulab ~] $parallel-E stop echo: AB stop C DAB

GNU Parallel uses-- no-run-if-empty to skip blank lines:

[21:28 sxuan@hulab ~] $(echo1; echo; echo 2) | parallel-- no-run-if-empty echo121.5 build command line

If no command is given after parallel, these parameters are treated as commands:

[21:29 sxuan@hulab ~] $parallel: ls' echo foo' pwda.txtb.txtc.txtjianchenmypipescriptssnake_testWGS_snakefoo/home/sxuan

In addition, the command can be a script file, a binary executable file, or a function of bash (the function must be exported with export-f)

[21:42 sxuan@hulab ~] $echo "echo\ $*" > s.sh [21:44 sxuan@hulab ~] $parallel. / s.sh:: "ab c f"1 2 3 4" ab c f1 2 3 41.6 replacement string

GNU Parallel supports multiple replacement strings, using {} by default, and using-I to change the replacement string symbol {}. The most common string substitutions include the following: {.}, remove the extension; {/}, remove the path and keep only the file name; {/.}, remove both the path and extension; {#}, output the task number. At the same time, you can specify symbols for each string substitution:-I corresponds to {};-- extensionreplace replaces {.};-- basenamereplace replaces {/};-- dirnamereplace replaces {/ /};-- basenameextensionreplace replaces {/.};-- seqreplace replaces {#}.

[22:02 sxuan@hulab ~] $parallel echo: A/B.C; parallel echo {}: A/B.C; parallel-I, echo,: A/B.CA/B.CA/B.CA/B.C [22:04 sxuan@hulab ~] $parallel echo {.}: A/B.C Parallel-- extensionreplace, echo,: A/B.CA/BA/B [22:08 sxuan@hulab ~] $parallel echo {/}: A/B.C; parallel-- basenamereplace, echo,: A/B.CB.CB.C [22:08 sxuan@hulab ~] $parallel echo {/ /}: A/B.C Parallel-- dirnamereplace, echo,: A/B.CAA [22:10 sxuan@hulab ~] $parallel echo {/.}: A/B.C; parallel-- basenameextensionreplace, echo,: A/B.CBB [22:13 sxuan@hulab ~] $parallel echo {#}: A B C; parallel-- seqreplace, echo,: a B C123123

At the same time, if you have more than one input source, you can specify the parameters of one input source by {number}:

[22:14 sxuan@hulab ~] $parallel-- xapply echo {1} and {2}:: a B: C DA and CB and D# can be used /. And. Change the specified replacement string [22:14 sxuan@hulab ~] $parallel echo / = {1 /} /. = {1 D/E#.}. = {1.}:: A/B.C D/E.F/=B.C / / = A /. = B. = A/B/=E.F / / = D /. = E. = position can be negative Denote the number of inverts [22:16 sxuan@hulab ~] $parallel echo 1 = {1} 2 = {3}-1 = {- 1}-2 = {- 2}-3 = {- 3}:: AB: CD: EF1A 2' C 3'E-1'C-3=A1=A 2'C 3'F-1'F-2'C-3=A1=A 2'D 3'E-1'E-2D-3=A1=A 2D'F-1' F-2D-3=A1=B 2C 3'E-1' E-1E-2C-3=B1=B 2' C 3F-1F-2C-3=B1=B 2D'3e-1E-2D'E-2D -3=B1=B 2 "D 3" F-1 "F-2" D-3=B1.7 enter and specify the parameter name by column

Use-- header to use the first value in each line of input as the parameter name.

[22:17 sxuan@hulab ~] $parallel-- xapply-- header: echo F1 = {F1} f2 = {f2}:: F1 A B: F2 C D | tee d.txtf1=A f2=Cf1=B f2roomD

Use-colsep to cut the lines in the file into columns as input parameters.

[22:31 sxuan@hulab ~] $perl-e'printf "F1\ tf2\ nA\ tB\ nC\ tD\ n"'> tsv-file.tsv [22:32 sxuan@hulab ~] $parallel-- header:-- colsep'\ t'echo F1 = {F1} f2 = {f2}: tsv-file.tsvf1=A f2=Bf1=C f2=D1.8 multiple parameters

-- xargs enters as many parameters as possible in a line (depending on the length of the parameter string), and you can specify the upper limit of parameters in a line with-s.

[09:44 sxuan@hulab ~] $perl-e'for (1... 30000) {print "$\ n"}'> num30000 [09:50 sxuan@hulab ~] $cat num30000 | parallel-- xargs echo | wc-l3 examples given on the official website here are 2 lines, and the result on my computer centos7 is 3 lines, which should be related to the linux version [09:50 sxuan@hulab ~] $cat num30000 | parallel-- xargs-s 10000 echo | wc-L17

For better concurrency, GNU Parallel distributes the parameters after the file has been read. GNU Parallel starts the second task after reading the last parameter, which allocates all the parameters equally to four tasks (if four tasks are specified). The first task is the same as the example above using-- xargs, but the second task is equally divided into four tasks, resulting in a total of five tasks. (oddly enough, my results are different from those of the official website tutorial.)

[11:44 sxuan@hulab ~] $cat num30000 | parallel-- jobs 4-m echo | wc-L6 # in the official website tutorials, here are 10 parameters assigned to 4 tasks that can be seen more clearly (the results here are consistent with the official website) [11:50 sxuan@hulab ~] $parallel-- jobs 4-m echo: {1.. 10} 1 234 5 67 8 910

The replacement string can be part of the output character. Use the-m parameter to indicate that each job does not repeat the output of "background" (context), while-X, contrary to-m, will repeat the output of "background text", which is understood by the following examples:

[11:36 sxuan@hulab ~] $parallel-- jobs 4 echo pre- {}-post:: A B C D E F Gpre-A-postpre-B-postpre-C-postpre-D-postpre-E-postpre-F-postpre-G-post [11:51 sxuan@hulab ~] $parallel-- jobs 4-m echo pre- {}-post:: A B C D E F Gpre-A B-postpre-C D-postpre-E F-postpre-G-post [11:57 sxuan@hulab ~] $parallel-- jobs 4-X echo pre- {}-post:: A B C D E F Gpre-A-post pre-B-postpre-C-post pre-D-postpre-E-post pre-F-postpre-G-post

Use-N to limit the number of parameters per line, where-N0 means that only one parameter is read at a time and is not entered (used as a counter).

[12:04 sxuan@hulab ~] $parallel-N4 echo 1 = {1} 2 = {2} 3 = {3}: A B C D E F G H1xB 3=C1=E 2F 3qG [12:05 sxuan@hulab ~] $parallel-N0 echo foo: 12 3foofoofoo1.9 reference

If the command line contains special characters, it needs to be protected by quotation marks. The perl script 'print "@ ARGV\ n' has the same function as linux's echo.

[12:05 sxuan@hulab ~] $perl-e'print "@ ARGV\ n"'AA

When you use GNU Parallel to run this command, the perl command needs to be wrapped in quotation marks, or you can use-Q to protect the perl command:

[12:08 sxuan@hulab ~] $parallel perl-e'print "@ ARGV\ n": This wont work [12:09 sxuan@hulab ~] $parallel-Q perl-e 'print "@ ARGV\ n": This worksThisworks [12:10 sxuan@hulab ~] $parallel perl-e\' 'print "@ ARGV\ n"':: Thisworks, tooThisworks,too1.10 removes spaces

Use-- trim to remove spaces at both ends of the parameter:

[12:10 sxuan@hulab ~] $parallel-- trim r echo pre- {}-post::'a 'pre-A-post [12:12 sxuan@hulab ~] $parallel-- trim l echo pre- {}-post:'a 'pre-A-post [12:12 sxuan@hulab ~] $parallel-trim lr echo pre- {}-post:'A 'pre-A-post1.11 controls the output

Use-- tag as the output prefix with parameters, and use-- tagstring to modify the output prefix:

[12:17 sxuan@hulab ~] $parallel-- tag echo foo- {}:: AB CA foo-AB foo-BC foo-C [12:19 sxuan@hulab ~] $parallel-- tagstring {}-bar echo foo- {}: AB CA-bar foo-AB-bar foo-BC-bar foo-C

-- dryrun acts like echo:

[12:19 sxuan@hulab ~] $parallel-- dryrun echo {}: AB Cecho Aecho Becho C [12:20 sxuan@hulab ~] $parallel echo {}:: AB CABC

-- verbose prints the command before running:

[12:21 sxuan@hulab ~] $parallel-- verbose echo {}:: AB Cecho Aecho Becho CABC

In general, GNU Parallel delays output until the execution of a set of commands is complete. Using-- ungroup, you can print out the completed parts immediately.

[13:45 sxuan@hulab ~] $parallel-J2 'printf "% s-start\ n% s" {}; sleep {}; printf "% s\ n"-middle;echo {}-end':: 42 12-start2-middle2-end1-start1-middle1-end4-start4-middle4-end [13:45 sxuan@hulab ~] $parallel-j2-ungroup' printf "% s-start\ n% s" {}; sleep {}; printf "% s\ n"-middle Echo {}-end': 42 14-start42-start2-middle2-end1-start1-middle1-end-middle4-end

Using-- ungroup is fast, but it can cause output confusion, and the line output of one task may be truncated by the output of another task. As shown in the example above, the second line of output is a mixture of two tasks: '4murley' and '2murstart'. Use-- linebuffer to avoid this problem (a little slower):

4-start2-start2-middle2-end1-start1-middle1-end4-middle4-end

Forces the output to be in order with the parameters-- keep-order/-k:

[13:53 sxuan@hulab ~] $parallel-J2-k'printf "% s-start\ n% s" {}; sleep {}; printf "% s\ n"-middle;echo {}-end': 4 2 14-start4-middle4-end2-start2-middle2-end1-start1-middle1-end1.12 saves the output to a file

GNU Parallel can save the output of each task to a file, the temporary file is saved in / tmp by default, and you can change it with-tmpdir (or modify $TMPDIR):

[13:55 sxuan@hulab ~] $parallel-- files:: a B C/tmp/parfmNTJ.par/tmp/parmioFz.par/tmp/pargaTxf.par [13:57 sxuan@hulab ~] $parallel-- tmpdir ~-- files:: a B C/home/sxuan/parLEXH7.par/home/sxuan/parXsKsR.par/home/sxuan/parZxytI.par [13:58 sxuan@hulab ~] $TMPDIR=~ parallel-- files: a B C/home/sxuan/par2tX6C.par/home/sxuan/parorPJy.par/home/sxuan/pari5TkI.par

The output file can be structurally saved-- results, and the output file contains not only standard output (stdout) but also standard error output (stderr):

[13:59 sxuan@hulab ~] $parallel-- results outdir echo:: AB CABC [14:00 sxuan@hulab ~] $tree outdir/outdir/ └── 1 ├── A │ ├── seq │ ├── stderr └── stdout ├── B │ ├── seq │ ├── stderr │ stdout └── C ├── seq ├── stderr └── stdout4 directories, 9 files

This is useful when using multiple variables:

#-- header: will take the first value as name and use that in the directory structure. [14:02 sxuan@hulab ~] $parallel-- header:-- results outdir echo:: F1 A B: f2 C DA CA DB CB D [14:02 sxuan@hulab ~] $tree outdir/outdir/ └── F1 ├── A │ └── f2 │ ├── C │ │ ├── seq │ │ ├── stderr │ │ └── stdout │ └── D │ ├── seq │ ├── stderr │ └── stdout └── B └── f2 ├── C │ ├── seq │ ├── stderr ─ stdout └── D ├── seq ├── stderr └── stdout9 directories 12 files1.13 control execution

Use-jobs/-j to specify the number of parallel tasks.

# execute 128hibernation commands with 64 tasks [15:02 sxuan@hulab ~] $time parallel-N0-j64 sleep 1: {1.. 128} real 0m2.759suser 0m0.657ssys 0m1.345s# by default, the number of parallel tasks is the same as the number of cpu cores So this command will take twice as long as the two tasks per cpu [15:03 sxuan@hulab ~] $time parallel-N0 sleep 1: {1... 128} real 0m3.478suser 0m0.656ssys 0m1.344s# two tasks per cpu [15:03 sxuan@hulab ~] $time parallel-N0-- jobs 200% sleep 1: {1.. 128} real 0m2.659suser 0m0.734ssys 0m1.423s# use-- jobs 0 means to perform as many parallel tasks as possible [15:03 sxuan@hulab ~] $time parallel-N0-- jobs 0 sleep 1: {1.. 128} real 0m2.135suser 0m0.651ssys 0m1.477s# except based on cpu utilization It can also be based on the number of cpu [15:03 sxuan@hulab ~] $time parallel-- use-cpus-instead-of-cores-N0 sleep 1: {1.. 128} real 1m5.499suser 0m0.950ssys 0m1.897s1.14 interaction

By using-- interactive, let the user decide whether to execute a task before it is executed.

[15:08 sxuan@hulab] $parallel-- interactive echo:: 12 3echo 1?. Yecho 2?. Yecho 3?. Y1231.15 takes time

To avoid the "shock effect" when job has a large number of IO operations, you can use the-- delay parameter to specify the time interval at which each job starts.

[15:16 sxuan@hulab ~] $parallel-- delay 2.5 echo Starting {}\; date:: 12 3Starting 1Tue Apr 17 15:21:41 CST 2018Starting 2Tue Apr 17 15:21:44 CST 2018Starting 3Tue Apr 17 15:21:46 CST 2018

If it is known that the task is unresponsive for more than a certain period of time, you can use-- timeout to specify the waiting time to avoid unnecessary waiting. GNU parallel calculates the median elapsed time of all tasks, so you can specify a multiple of the median time.

[15:35 sxuan@hulab ~] $parallel-- timeout 4.1 sleep {}\; echo {}: 24 6824 [15:36 sxuan@hulab ~] $parallel-- timeout 200% sleep {}\; echo {}: 2.12.2 3 7 2.32.12.22.331.16 displays task progress information

GNU parallel can be used to dynamically display task progress information in several ways, such as:

Parallel-- eta sleep:: 1 3 2 2 1 3 3 2 1parallel-- progress sleep:: 1 3 2 2 1 3 3 2 1seq 1000 | parallel-j10-- bar'(echo-n {}; sleep 0.1)'2 > > (zenity-- progress-- auto-kill-- auto-close)

Use the-- joblog parameter to generate log files for each task:

[15:39 sxuan@hulab ~] $parallel-- joblog / tmp/log exit:: 12 30 [15:41 sxuan@hulab] $cat / tmp/logSeq Host Starttime JobRuntime Send Receive Exitval Signal Command1: 1523950890.344 0.018 00 1 0 exit 12: 1523950890.350 0.014 00 20 exit 23: 1523950890.357 0.006 00 3 0 exit 34 : 1523950890.363 0.006 00 00 exit 0

Rerun failed tasks through the-- resume-failed parameter;-- retry-failed works like-- resume-failed, except that-- resume-failed reads failed tasks from the command line, while-- retry-failed reads failed tasks from log files:

[15:41 sxuan@hulab ~] $parallel-- resume-failed-- joblog / tmp/log exit:: 123 000 [15:48 sxuan@hulab] $cat / tmp/logSeq Host Starttime JobRuntime Send Receive Exitval Signal Command1: 1523950890.344 0.018 00 10 exit 12: 1523950890.350 0.014 00 20 exit 23: 1523950890.357 0.006 00 3 0 exit 34: 1523950890.363 0.006 00 00 exit 01: 1523951289.575 0.029 00 1 0 exit 12: 1523951289.580 0.025 00 2 0 exit 23: 1523951289.585 0.019 00 3 0 exit 35: 1523951289.591 0.013 00 00 exit 06: 1523951289 .604 0.004 00 exit 0 [15:48 sxuan@hulab ~] $parallel-- retry-failed-- joblog / tmp/log [15:50 sxuan@hulab ~] $cat / tmp/logSeq Host Starttime JobRuntime Send Receive Exitval Signal Command1: 1523950890.344 0.018 00 10 exit 12: 1523950890.350 0.014 00 20 exit 23: 1523950890.357 0.006 00 3 0 exit 34: 1523950890.363 0.006 00 00 exit 01: 1523951289.575 0.029 00 1 0 exit 12: 1523951289.580 0.025 00 2 0 exit 23: 1523951289.585 0.019 00 3 0 exit 35: 1523951289.591 0.013 00 00 Exit 06: 1523951289.604 0.004 00 exit 01: 1523951445.089 0.013 00 10 exit 12: 1523951445.094 0.009 00 20 exit 23: 1523951445.102 0.007 00 3 0 exit 31.17 abort the task

GNU parallel supports terminating tasks in certain situations (such as the first failure or success, or 20% task failure). There are two types of terminating tasks, one is immediate termination (specified by-- halt now), killing all running tasks and stopping generating new tasks, and the other is terminating later (specified by-- halt soon), stopping generating new tasks and waiting for running tasks to complete.

[15:50 sxuan@hulab ~] $parallel-j2-- halt soon,fail=1 echo {}\; exit {}:: 0012 3001parallel: This job failed:echo 1; exit 1parallel: Starting no more jobs. Waiting for 1 jobs to finish.2parallel: This job failed:echo 2; exit 2 [16:04 sxuan@hulab ~] $parallel-j2-- halt now,fail=1 echo {}\; exit {}: 0012 3001parallel: This job failed:echo 1; exit 1 [16:05 sxuan@hulab ~] $parallel-j2-- halt soon,fail=20% echo {}\; exit {}: 01 2 3 4 5 6 7 8 901parallel: This job failed:echo 1; exit 12parallel: This job failed:echo 2; exit 2parallel: Starting no more jobs. Waiting for 1 jobs to finish.3parallel: This job failed:echo 3; exit 3 [16:05 sxuan@hulab ~] $parallel-j2-- halt now,success=1 echo {}\; exit {}: 1230 4 5 61230parallel: This job succeeded:echo 0; exit 0

GNU parallel also supports a retry after a task fails-- retries:

[16:06 sxuan@hulab ~] $parallel-k-- retries 3 'echo tried {} > / tmp/runs; echo completed {}; exit {}':: 1 2 0completed 1completed 2completed 0 [16:09 sxuan@hulab ~] $cat / tmp/runstried 1tried 2tried 0tried 1tried 2tried 1tried 2

Refer to the official getting started documentation for the advanced use of the stop signal.

1.18 Resource restrictions

GNU parallel can check the load of the system to prevent overload before starting a new task (load can be specified through-- load), as well as check whether the system uses swap space (swap) (restrict the use of swap through-- noswap).

[16:09 sxuan@hulab ~] $parallel-- load 100% echo load is less than {} job per cpu: 1load is less than 1 job per cpu [16:19 sxuan@hulab ~] $parallel-- noswap echo the system is not swapping:: nowthe system is not swapping now

At the same time, for some programs that take up a lot of memory, parallel checks that the task starts the task only when the memory is satisfied (specify the amount of memory required through-- memfree), and kills the newly started task when the memory is less than 50% after starting the task, and restarts the killed task until the task is completed.

[16:24 sxuan@hulab ~] $parallel-- memfree 1G echo will run if more than 1 GB is: freewill run if more than 1 GB is free

You can also specify the priority of the task through-- nice.

[16:27 sxuan@hulab ~] $parallel-- nice 17 echo this is being run with nice-n: 17this is being run with nice-n 171.19 remote operation

You can use-S host for remote login: parallel-S username@$SERVER1 echo running on: username@$SERVER1

1.20 File transfer

Rsync is used for GNU parallel file transfer.

Echo This is input_file > input_fileparallel-S $SERVER1-- transferfile {} cat: input_file

See the getting started documentation for more remote operations.

1.21-pipe

-- the pipe parameter allows us to divide the input (stdin) into multiple block, and then assign it to multiple tasks and multiple cpu to achieve load balancing, and the final result order is the same as the original order. Use the-- block parameter to specify the size of each block, which defaults to 1m.

[17:15 sxuan@hulab ~] $perl-e'for (1.. 1000000) {print "$\ n"}'> num1000000 [17:16 sxuan@hulab ~] $cat num1000000 | parallel-- pipe wc165668 165668 1048571149796 149796 1048572149796 149796 1048572149796 149796 1048572149796 149796 1048572149796 149796 1048572 85352 597765

If you don't care about the order of the results and just want to get the results quickly, you can use the-- round-robin parameter. Without this parameter, each file starts a command, and after using this parameter, these file blocks are assigned to the job task (specified by-- jobs). If you want to distribute more evenly, you can also specify the-- block parameter.

[17:17 sxuan@hulab ~] $cat num1000000 | parallel-- pipe-J4-- round-robin wc299592 299592 2097144315464 2097143149796 149796 1048572235148 235148 1646037 [17:23 sxuan@hulab ~] $cat num1000000 | parallel-- pipe-J4-- block 2m-- round-robin wc299593 299593 20971515465 315465 2091509593 299593 2097151 85349 85349 597444 "how to use Linux parallel Job execution tool GNU Parallel" is introduced here. Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.