(VARCHAR(100)) and contents (arbitr

(VARCHAR(100)) and contents (arbitrary text). Finally, the Rankings
table contains three attributes: pageURL (VARCHAR(100)),
pageRank (INT), and avgDuration(INT).
The data generator yields 155 million UserVisits records (20GB)
and 18 million Rankings records (1GB) per node. Since the data
generator does not ensure that Rankings and UserVisits tuples with
the same value for the URL attribute are stored on the same node, a
repartitioning is done during the data load, as described later.
Records for both the UserVisits and Rankings data sets are stored
in HDFS as plain text, one record per line with fields separated by
a delimiting character. In order to access the different attributes
at run time, the Map and Reduce functions split the record by the
delimiter into an array of strings.
6.2.1 Data Loading
We report load times for two data sets, Grep and UserVisits in
Fig. 3 and Fig. 4. While grep data is randomly generated and requires
no preprocessing, UserVisits needs to be repartitioned by
destinationURL and indexed by visitDate for all databases during
the load in order to achieve better performance on analytical queries
(Hadoop would not benefit from such repartitioning). We describe,
briefly, the loading procedures for all systems:
Hadoop: We loaded each node with an unaltered UserVisits data
file. HDFS automatically breaks the file into 256MB blocks and
stores the blocks on a local DataNode. Since all nodes load their
data in parallel, we report the maximum node load time from each
cluster. Load time is greatly affected by stragglers. This effect
is especially visible when loading UserVisits, where a single slow
node in the 100-node cluster pushed the overall load time to 4355
seconds and to 2600 seconds on the 10-node cluster, despite the
average load time of only 1100 seconds per node.
HadoopDB: We set the maximum chunk size to 1GB. Each chunk
is located in a separate PostgreSQL database within a node, and
processes SQL queries independently of other chunks. We report
the maximum node load time as the entire load time for both Grep
and UserVisits.
Since the Grep dataset does not require any preprocessing and is
only 535MB of data per node, the entire data was loaded using the
standard SQL COPY command into a single chunk on each node.
The Global Hasher partitions the entire UserVisits dataset across
all nodes in the cluster. Next, the Local Hasher on each node retrieves
a 20GB partition from HDFS and hash-partitions it into 20
smaller chunks, 1GB each. Each chunk is then bulk-loaded using
COPY. Finally, a clustered index on visitDate is created for each
chunk.
The load time for UserVisits is broken down into several phases.
The first repartition carried out by Global Hasher is the most expensive
step in the process. It takes nearly half the total load time,
14,000 s. Of the remaining 16,000 s, locally partitioning the data
into 20 chunks takes 2500 s (15.6%), the bulk copy into tables takes
5200 s (32.5%), creating clustered indices, which includes sorting,
takes 7100 s (44.4%), finally vacuuming the databases takes
1200 s (7.5%). All the steps after global repartitioning are executed
in parallel on all nodes. We observed individual variance in load
times. Some nodes required as little as 10,000 s to completely load
UserVisits after global repartitioning was completed.
Vertica: The loading procedure for Vertica is analogous to the one
described in [23]. The loading time improved since then because a
newer version of Vertica (3.0) was used for these experiments. The
key difference is that now bulk load COPY command runs on all
nodes in the cluster completely in parallel.
DBMS-X:We report the total load time including data compression
and indexing from [23].

ผลลัพธ์ (ไทย) 1:

(VARCHAR(100)) และเนื้อหา (ข้อกำหนด) ในที่สุด จัดอันดับตารางประกอบด้วยแอตทริบิวต์สาม: pageURL (VARCHAR(100))รถเข้า (INT), และ avgDuration(INT)เครื่องกำเนิดไฟฟ้าข้อมูลทำให้ 155 ล้าน UserVisits ระเบียน (20GB)และ 18 ล้านอันดับระเบียน (1GB) สำหรับแต่ละโหนด ตั้งแต่ข้อมูลเครื่องกำเนิดไฟฟ้าให้ tuples ที่จัดอันดับและ UserVisits ด้วยค่าเดียวกันสำหรับแอตทริบิวต์ URL เก็บอยู่บนโหนดเดียวกัน การrepartitioning แล้วระหว่างโหลดข้อมูล ตามที่อธิบายไว้ในภายหลังเก็บระเบียนสำหรับชุดข้อมูลของ UserVisits และจัดอันดับใน HDFS เป็นข้อความล้วน หนึ่งระเบียนสำหรับแต่ละบรรทัดมีเขตคั่นด้วยdelimiting อักขระ การเข้าถึงแอตทริบิวต์แตกต่างกันเวลา แผนที่และลดฟังก์ชันแบ่งเรกคอร์ดโดยการตัวในอาร์เรย์ของสตริงการ6.2.1 การโหลดข้อมูลเรารายงานเวลาโหลดค่า Grep และ UserVisits ในFig. 3 และ Fig. 4 Grep ข้อมูลถูกสร้างขึ้นแบบสุ่ม และต้องไม่ประมวลผลเบื้องต้น UserVisits จำเป็นต้องมี repartitioned ด้วยdestinationURL และการสร้างดัชนี โดย visitDate สำหรับฐานข้อมูลทั้งหมดระหว่างการใช้งานเพื่อให้บรรลุประสิทธิภาพในแบบสอบถามวิเคราะห์(อย่างไร Hadoop จะไม่ได้รับประโยชน์จาก repartitioning ดังกล่าว) เราอธิบายสั้น ๆ โหลดขั้นตอนสำหรับระบบทั้งหมด:อย่างไร Hadoop: เราโหลดโหนแต่ละข้อมูล UserVisits unalteredแฟ้ม HDFS แบ่งแฟ้มโดยอัตโนมัติลงในบล็อก 256MB และเก็บบล็อก DataNode ท้องถิ่น ตั้งแต่โหลดโหนทั้งหมดของพวกเขาข้อมูลพร้อมกัน เรารายงานเวลาโหลดโหนสูงสุดจากแต่ละคลัสเตอร์ เวลาโหลดมากได้รับผลกระทบ โดย stragglers ลักษณะพิเศษนี้มองเห็นได้โดยเฉพาะอย่างยิ่งเมื่อโหลด UserVisits เดียวช้าโหนดในคลัสเตอร์โหน 100 ผลักเวลาโหลดรวมไป 4355วินาที และ วินาที 2600 บนคลัสเตอร์โหน 10 แม้มีการเวลาโหลดเฉลี่ย 1100 วินาทีต่อโหนดHadoopDB: เราตั้งขนาดก้อนข้อมูลสูงสุดถึง 1GB แต่ละกลุ่มตั้งอยู่ในฐานข้อมูล PostgreSQL แยกต่างหากภายในโหนด และประมวลผลแบบสอบถาม SQL อิสระก้อนอื่น ๆ เรารายงานเวลาโหลดโหนสูงสุดเป็นเวลาทั้งการโหลดสำหรับทั้ง Grepและ UserVisitsเนื่องจากชุดข้อมูล Grep ต้องการประมวลผลเบื้องต้น และเป็นเพียง 535MB ของข้อมูลสำหรับแต่ละโหน ข้อมูลทั้งหมดถูกโหลดโดยใช้การคำสั่ง SQL สำเนามาตรฐานเป็นท่อเดียวบนแต่ละโหนดUserVisits ชุดข้อมูลทั้งหมดข้ามผนังกั้น Hasher โลกโหนทั้งหมดในคลัสเตอร์ ดึง Hasher ท้องถิ่นบนโหนแต่ละ20GB แบ่งพาร์ติชันจาก HDFS และแฮกั้นจะเป็น 20ก้อนเล็ก 1GB แต่ละกลุ่มแล้วจำนวนมากโหลดโดยใช้คัดลอก ในที่สุด สร้างดัชนีกลุ่มใน visitDate สำหรับแต่ละกลุ่มเวลาโหลดสำหรับ UserVisits จะแบ่งออกเป็นระยะต่าง ๆRepartition แรกที่ดำเนินการ โดย Hasher โลกจะแพงที่สุดขั้นตอนในกระบวนการ ใช้เวลาเกือบครึ่งโหลดรวมเวลา14000 s ของ 16000 เหลือ s พาร์ทิชันข้อมูลภายในจำนวนมากคัดลอกลงในตารางจะเป็น 20 ก้อนเวลา 2500 s (15.6%),5200 s (32.5%), สร้างดัชนีคลัสเตอร์ ซึ่งรวมถึงการเรียงลำดับใช้ 7100 s (44.4%), และสุดท้าย vacuuming ฐานข้อมูลใช้1200 s (7.5%) ดำเนินการขั้นตอนทั้งหมดหลังจาก repartitioning สากลพร้อมกันบนโหนทั้งหมด เราสังเกตผลต่างแต่ละในการโหลดครั้ง บางโหนที่จำเป็นเพียงเล็กน้อยที่ 10000 s โหลดอย่างสมบูรณ์UserVisits หลังจากโลก repartitioning เสร็จVertica: มีขั้นตอนการโหลด Vertica คู่กับอธิบายไว้ใน [23] เวลาปรับปรุงตั้งแต่นั้นเนื่องจากการVertica (3.0) รุ่นใหม่กว่าถูกใช้สำหรับการทดลองเหล่านี้ ที่ความแตกต่างที่สำคัญคือตอนนี้โหลดจำนวนมากสำเนาคำสั่งที่ทำงานบนทั้งหมดโหนดในคลัสเตอร์ทั้งหมดในขนานDBMS X: เรารายงานเวลาโหลดรวมรวมรวมข้อมูลและจัดทำดัชนีจาก [23]

ผลลัพธ์ (ไทย) 2:

(VARCHAR (100)) และเนื้อหา (ข้อความพล) ในที่สุดการจัดอันดับตารางมีสามคุณลักษณะ: pageURL (VARCHAR (100)) PageRank (INT) และ avgDuration (INT). เครื่องกำเนิดไฟฟ้าข้อมูลอัตราผลตอบแทน 155,000,000 บันทึก UserVisits (20GB) และ 18 ล้านระเบียนการจัดอันดับ (1GB) ต่อโหนด เนื่องจากข้อมูลกำเนิดไม่แน่ใจว่าการจัดอันดับและ tuples UserVisits มีค่าเหมือนกันสำหรับแอตทริบิวต์URL ที่จะถูกเก็บไว้บนโหนดเดียวกันrepartitioning จะทำในระหว่างการโหลดข้อมูลตามที่อธิบายไว้ในภายหลัง. ประวัติทั้ง UserVisits และการจัดอันดับข้อมูลที่เป็นชุด เก็บไว้ในHDFS เป็นข้อความธรรมดาคนหนึ่งบันทึกต่อบรรทัดที่มีเขตข้อมูลแยกจากกันโดยตัวละคร delimiting เพื่อให้สามารถเข้าถึงคุณลักษณะที่แตกต่างกันในเวลาทำงานแผนที่และลดฟังก์ชั่นแยกบันทึกโดยที่คั่นเป็นอาร์เรย์ของสตริง. 6.2.1 โหลดข้อมูลเรารายงานเวลาในการโหลดสองชุดข้อมูลGrep และ UserVisits ในรูป และรูปที่ 3 4. ขณะที่ข้อมูล grep จะถูกสร้างขึ้นแบบสุ่มและต้องประมวลผลเบื้องต้นไม่มีUserVisits จะต้องมีการ repartitioned โดยdestinationURL และจัดทำดัชนีโดย visitDate สำหรับฐานข้อมูลทั้งหมดในระหว่างการโหลดในการสั่งซื้อเพื่อให้เกิดประสิทธิภาพที่ดีขึ้นในการวิเคราะห์คำสั่ง(Hadoop จะไม่ได้รับประโยชน์จาก repartitioning ดังกล่าว) เราอธิบายสั้น ๆ ขั้นตอนการโหลดสำหรับระบบทั้งหมด: Hadoop: เราโหลดแต่ละโหนดที่มีการเปลี่ยนแปลง UserVisits ข้อมูลไฟล์ HDFS โดยอัตโนมัติแบ่งไฟล์ลงในบล็อก 256MB และเก็บบล็อกบนDataNode ท้องถิ่น ตั้งแต่โหนดทั้งหมดของพวกเขาโหลดข้อมูลในแบบคู่ขนานที่เรารายงานเวลาในการโหลดโหนดสูงสุดจากแต่ละกลุ่ม เวลาในการโหลดได้รับผลกระทบอย่างมากโดยพลัดหลง ผลกระทบนี้จะมองเห็นได้โดยเฉพาะอย่างยิ่งเมื่อโหลด UserVisits ที่ช้าเดียวโหนดในกลุ่ม100 โหนดผลักเวลาในการโหลดโดยรวม 4355 วินาทีและ 2,600 วินาทีในกลุ่ม 10 โหนดแม้จะมีเวลาในการโหลดเฉลี่ยเพียง1,100 วินาทีต่อโหนด . HadoopDB: เรากำหนดขนาดก้อนสูงสุดถึง 1GB แต่ละก้อนตั้งอยู่ในฐานข้อมูล PostgreSQL แยกต่างหากภายในโหนดและประมวลผลแบบสอบถามSQL เป็นอิสระจากชิ้นอื่น ๆ เรารายงานเวลาโหลดโหนดสูงสุดเป็นเวลาในการโหลดทั้งหมดทั้ง Grep และ UserVisits. ตั้งแต่ชุด Grep ไม่จำเป็นต้องประมวลผลเบื้องต้นใด ๆ และเป็นเพียง535MB ของข้อมูลต่อโหนดข้อมูลทั้งหมดถูกโหลดโดยใช้มาตรฐานสำเนาคำสั่งSQL เข้าไปเดียว ก้อนในแต่ละโหนด. สากล Hasher พาร์ทิชันชุดข้อมูลทั้งหมด UserVisits ทั่วทุกโหนดในคลัสเตอร์ ถัดไป Hasher ท้องถิ่นในแต่ละโหนดดึงพาร์ทิชัน20GB จาก HDFS และกัญชาพาร์ทิชันมันเป็น 20 ชิ้นเล็ก, 1GB แต่ละ ก้อนแต่ละกลุ่มแล้วโหลดใช้COPY ในที่สุดดัชนีคลัสเตอร์ใน visitDate ถูกสร้างขึ้นสำหรับแต่ละก้อน. เวลาโหลด UserVisits จะแบ่งออกเป็นหลายขั้นตอน. repartition แรกที่ดำเนินการโดย Hasher ทั่วโลกมีราคาแพงที่สุดขั้นตอนในกระบวนการ มันต้องใช้เวลาเกือบครึ่งหนึ่งของเวลาในการโหลดรวม14,000 s ส่วนที่เหลืออีก 16,000 s ในประเทศแบ่งข้อมูลออกเป็น20 ชิ้นใช้เวลา 2,500 วินาที (15.6%) สำเนาจำนวนมากลงในตารางเวลา5200 วินาที (32.5%), การสร้างดัชนีคลัสเตอร์ซึ่งรวมถึงการเรียงลำดับการใช้เวลา7,100 วินาที (44.4%) ในที่สุดก็ดูดฝุ่นฐานข้อมูลจะใช้เวลา1,200 วินาที (7.5%) ทุกขั้นตอนหลังจาก repartitioning ทั่วโลกจะดำเนินการในแบบคู่ขนานบนโหนดทั้งหมด เราสังเกตเห็นความแตกต่างของแต่ละบุคคลในการโหลดครั้ง โหนดที่จำเป็นบางอย่างเป็นเพียง 10,000 ที่จะสมบูรณ์โหลดUserVisits หลังจาก repartitioning ทั่วโลกเป็นที่เรียบร้อยแล้ว. Vertica: ขั้นตอนการโหลดสำหรับ Vertica จะคล้ายคลึงกับที่อธิบายไว้ใน[23] เวลาในการโหลดที่ดีขึ้นตั้งแต่นั้นเพราะรุ่นที่ใหม่กว่า Vertica (3.0) ถูกนำมาใช้สำหรับการทดลองเหล่านี้ แตกต่างที่สำคัญคือว่าตอนนี้โหลดทั้งกลุ่มวิ่งสำเนาคำสั่งในทุกโหนดในคลัสเตอร์สมบูรณ์ในแบบคู่ขนาน. DBMS-X: เรารายงานเวลาในการโหลดรวมรวมถึงการบีบอัดข้อมูลและการจัดทำดัชนีจาก[23]

ผลลัพธ์ (ไทย) 3:

( VAIO HK ( 100 ) และเนื้อหา ( ข้อความโดยพลการ ) ในที่สุดการจัดอันดับ
ตารางประกอบด้วยสามคุณสมบัติ : pageurl ( VAIO HK ( 100 ) ) ,
PageRank ( int ) และ avgduration ( INT ) .
เครื่องกำเนิดไฟฟ้าข้อมูลผลผลิต 155 ล้านบาท uservisits ประวัติ ( 20GB )
18 ล้านอันดับประวัติ ( 1GB ) ต่อโหนด เนื่องจากข้อมูล
เครื่องกำเนิดไฟฟ้าไม่ได้มั่นใจว่าอันดับและ uservisits ทูเปิลกับ
ค่าเดียวกันสำหรับ URL ที่คุณลักษณะจะถูกเก็บไว้บนโหนดเดียวกัน ,
repartitioning เสร็จระหว่างโหลดข้อมูลตามที่อธิบายไว้ในภายหลัง .
ประวัติทั้ง uservisits และข้อมูลการจัดอันดับชุดเก็บไว้
ใน hdfs เป็นข้อความธรรมดา หนึ่งรายการต่อบรรทัดกับสาขาที่แยกจากกันโดยการ delimiting อักขระ เพื่อให้สามารถเข้าถึงคุณลักษณะที่แตกต่างกันในเวลา
วิ่งแผนที่ และลดการทำงานแยกบันทึกโดย
ตัวคั่นในอาร์เรย์สตริง ข้อมูล โหลด 6.2.1

เรารายงานเวลาโหลดสองชุดข้อมูลสามารถ uservisits
, และในรูปที่ 3 และมะเดื่อ 4 ขณะที่ข้อมูลสามารถถูกสร้างขึ้นแบบสุ่มและต้องไม่ติดกัน uservisits
,
destinationurl ต้อง repartitioned โดยดัชนีทั้งหมดและ visitdate ฐานข้อมูลในระหว่าง
โหลดเพื่อให้บรรลุประสิทธิภาพที่ดีขึ้นในการค้นหา
( Hadoop จะไม่ได้รับประโยชน์จาก repartitioning ) เราอธิบาย
สั้น ๆ , โหลดขั้นตอนทุกระบบ :
Hadoop : เราโหลดแต่ละโหนดมีไม่เปลี่ยนแปลง
uservisits ข้อมูลไฟล์ hdfs โดยอัตโนมัติแบ่งไฟล์เป็น 256MB บล็อกและบล็อกใน datanode
ร้านค้าท้องถิ่น เนื่องจากทุกโหนดโหลดข้อมูล
ในแบบคู่ขนานเรารายงานสูงสุดจากแต่ละโหนดโหลด
คลัสเตอร์ เวลาในการโหลดจะได้รับผลกระทบอย่างมากโดยพลัดหลง . นี้ผล
จะมองเห็นได้โดยเฉพาะอย่างยิ่งเมื่อโหลด uservisits ที่โหนดช้า
เดียวใน 100 โหนดคลัสเตอร์ผลักเวลา โหลด โดยรวม 4355
วินาที และ 10 วินาที 2600 บนโหนดคลัสเตอร์ แม้จะมีเวลาเพียง 1100 โหลด

hadoopdb : วินาทีต่อโหนดเรากำหนดขนาดท่อสูงสุดถึง 1GB . แต่ละชิ้น
ตั้งอยู่ในฐานข้อมูล PostgreSQL แยกภายในโหนด และกระบวนการ SQL แบบสอบถามอิสระ
ของชิ้นอื่น ๆ เรารายงาน
สูงสุดโหนดโหลดเวลาโหลดนานทั้งหมด ทั้งสามารถ และ uservisits
.
เนื่องจากสามารถไม่ต้องมีการเตรียมข้อมูลและ
535mb เท่านั้นของข้อมูลต่อโหนด ข้อมูลทั้งหมดถูกโหลดโดยใช้
มาตรฐานคัดลอก SQL คำสั่งลงในก้อนเดียวในแต่ละโหนด hasher
( ข้อมูลทั้งหมดในพาร์ทิชัน uservisits
โหนดในคลัสเตอร์ ต่อไป hasher ท้องถิ่นในแต่ละโหนดเรียก
20GB พาร์ทิชันจาก hdfs และพาร์ทิชันสับมันลง 20
chunks , 1GB แต่ละ แต่ละชิ้นจะเป็นกลุ่มโหลดโดยใช้
copy ในที่สุด เมื่อดัชนีใน visitdate ขึ้น

แต่ละก้อนเวลาโหลด uservisits แบ่งออกเป็นหลายระยะ แรก repartition
ดำเนินการโดยส่วนกลาง hasher เป็นขั้นตอนราคาแพง
ที่สุดในกระบวนการ มันใช้เวลาเกือบครึ่งหนึ่งของทั้งหมด โหลด เวลาที่เหลืออีก 16 , 000 , 000 s

s ภายในแบ่งข้อมูลเป็น 20 ชิ้นใช้ 2500 S ( 15.6% ) เป็นกลุ่มที่คัดลอกลงในตารางใช้
5200 S ( 32.5 เปอร์เซ็นต์ ) , การสร้างกลุ่มดัชนีซึ่งรวมถึงการใช้ 7100 , s (
/ % ) ในที่สุด vacuuming ฐานข้อมูลใช้
1200 S ( 7.5% ) ขั้นตอนทั้งหมดจะดำเนินการหลังจากโลก repartitioning
ขนานทุกโหนด เราพบความแปรปรวนในแต่ละโหลด
ครั้ง บางจุดที่จำเป็นเล็กน้อยเป็น 10 , 000 s สมบูรณ์โหลด
uservisits หลังจากโลก repartitioning แล้วเสร็จ .
ฐาน :