निम्नलिखित चला है:

# run_join_time.sh
echo 'hash,time' > 'join_timings.csv'

for HASH in $(git rev-list --ancestry-path 1.10.0..1.12.4 | awk 'NR == 1 || NR % 10 == 0');
do git checkout $HASH && R CMD INSTALL . && Rscript time_join.R $HASH;
done

# time_join.R
library(data.table)
library(microbenchmark)

hash = commandArgs(trailingOnly = TRUE)

aa = data.table(a = seq(1,100), b = rep(0, 100))
bb = data.table(a = seq(1,100), b = rep(1, 100))

fwrite(data.table(
  hash = hash,
  time = microbenchmark(times = 1000L, aa[bb, b := i.b, on=.(a)])$time
), 'join_timings.csv', append = TRUE)

फिर इस प्लॉट को बनाने के लिए निम्न कार्य किया

library(data.table)
times = fread('join_timings.csv')

times[ , date := as.POSIXct(system(sprintf("git show --no-patch --no-notes --pretty='%%cd' %s", .BY$hash), intern = TRUE), by = hash]
times[ , date := as.POSIXct(date, format = '%a %b %d %T %Y %z', tz = 'UTC')]
times[ , date := as.IDate(date)]
setorder(times, date)

tags = system('
for TAG in $(git tag);
  do git show --no-patch --no-notes --pretty="$TAG\t%cd" $TAG;
done
', intern = TRUE)

tags = setDT(tstrsplit(tags, '\t'))
setnames(tags, c('tag', 'date'))
tags[ , date := as.POSIXct(date, format = '%a %b %d %T %Y %z', tz = 'UTC')]
tags[ , date := as.IDate(date)]

times[ , {
  par(mar = c(7.1, 4.1, 2.1, 2.1))
  y = boxplot(I(time/1e6) ~ date, log = 'y', notch = TRUE, pch = '.',
              las = 2L, xlab = '', ylab = 'Execution time (ms)', cex.axis = .8)
  x = unique(date)
  idx = findInterval(tags$date, x)
  abline(v = idx[idx>0L], lty = 2L, col = 'red')
  text(idx[idx>0L], .7*10^(par('usr')[4L]), tags$tag[idx>0L], 
       col = 'red', srt = 90)
  NULL
}]

शुरू करने के बाद मुझे एहसास हुआ कि मैं इसका उपयोग करके इसे थोड़ा सुव्यवस्थित कर सकता हूं

echo 'hash,time,date' > 'join_timings.csv'

for HASH in $(git rev-list --ancestry-path 1.10.0..1.12.4 | awk 'NR == 1 || NR % 10 == 0');
do git checkout $HASH && R CMD INSTALL . --preclean && Rscript time_join.R $HASH $(git show --no-patch --no-notes --pretty='%cd' $HASH);
done

library(data.table)
library(microbenchmark)

args = commandArgs(trailingOnly = TRUE)
hash = args[1L]
date = as.POSIXct(args[2L], format = '%a %b %d %T %Y %z', tz = 'UTC'))

aa = data.table(a = seq(1,100), b = rep(0, 100))
bb = data.table(a = seq(1,100), b = rep(1, 100))

fwrite(data.table(
  hash = hash,
  date = date,
  time = microbenchmark(times = 1000L, aa[bb, b := i.b, on=.(a)])$time
), 'join_timings.csv', append = TRUE)

प्रतिबद्ध समय को सीधे बेंचमार्क में जोड़ने के लिए

join_times.txt

हाय माइकल चिरिको, मैंने दो बार पढ़ा है
लेकिन 2016 से 2019 तक की टाइमलाइन का वास्तव में क्या मतलब है? क्या यह डेटाटेबल का एक संस्करण है?

न केवल संस्करण बल्कि विशिष्ट कमिट। मुझे संस्करणों का कुछ सीमांकन करने का प्रयास करने दें, एक अच्छा विचार जिसे मैं जोड़ना भूल गया था

@MichaelChirico आपका ग्राफ बहुत अच्छा लग रहा है, जो याद आ रहा था वह उसकी व्याख्या थी :) अनुमान लगाकर मैं कहूंगा कि 100 की लंबाई के इनपुट के लिए नया समानांतर फ़ोर्डर पहले की तुलना में धीमा है। कौन सा आईएमओ ठीक है, क्योंकि ये अभी भी माइक्रोसेकंड हैं। यह निश्चित रूप से ओवरहेड को कम करने के लायक है लेकिन प्राथमिकता सबसे सामान्य उपयोग परिदृश्यों में संसाधनों की कमी होनी चाहिए। 100 इनपुट की लंबाई पर 10000 बार लूपिंग निश्चित रूप से उनमें से एक नहीं है।

1.12.0 समाचार देखने के बाद मेरा भी यही अनुमान था। सिंगल थ्रेडेड चलाने की कोशिश करेंगे।

@jangorecki , यदि आप सरल गणित करते हैं तो यह हजारों माइक्रोसेकंड यानी मिलीसेकंड है
इस परीक्षण की प्रेरणा मेरी वर्तमान परियोजना थी जहां मैं 40,000 पंक्तियों के साथ 7-8 बार तालिकाओं में शामिल होता हूं
इसके पहले 18 सेकंड लगते हैं, बाद में 40 सेकंड लगते हैं
मेरे परीक्षण में वर्ण कुंजी भी शामिल है
मैंने 3.6+1.12 स्थापित किया और फिर इसे 3.4+1.10 . पर वापस लाया
मुझे लगता है कि यह सामान्य स्थिति नहीं है इसलिए यह मुद्दा यहाँ है

हाँ ग्राफ़ वाकई कमाल का है; हमें इसे और अधिक करना चाहिए और इसे स्वचालित करना चाहिए।

लेकिन मूल रिपोर्ट R 3.4 की तुलना R 3.6 से करती है, जिसके बीच में R 3.5 है। हम जानते हैं कि आर 3.5 ने मैक्रोज़ से (थोड़ा भारी) फ़ंक्शन के लिए ALTREP के REAL (), INTEGER () के परिवर्तन के माध्यम से data.table को प्रभावित किया।

@ vk111 क्या आप कृपया सीआरएएन पर अब v1.12.4 के साथ अपने परीक्षण दोबारा चला सकते हैं। इससे बेहतर नहीं हो सकता? हम R 3.5+ से निपटने के लिए R API को लूप से बाहर ले जा रहे हैं। अगले चरण के रूप में, यह जानना बहुत अच्छा होगा कि आप v1.12.4 को कैसे ढूंढते हैं। क्या आप अपनी मशीन के बारे में अधिक जानकारी भी शामिल कर सकते हैं; जैसे ऑपरेटिंग सिस्टम, रैम और सीपीयू की संख्या।

@matt , करेंगे

हाय @mattdowle ,

Ive को 1.12.4 (+R 3.6.1) में अपडेट किया गया - मूल रूप से यूनिट टेस्ट और my func के लिए समान अंक हैं
मैं यहां केवल अनुक्रमण के बिना चरित्र के साथ जुड़ने पर विचार करूंगा - एक बेंचमार्क के रूप में
यूनिट टेस्ट (जैसा कि पहली पोस्ट में बताया गया है)
3.6.1: 6.87 सेकेंड बिना इंडेक्स
3.4.0: 3.02 सेकंड (कोई अनुक्रमणिका नहीं)

प्रोजेक्ट से मेरा कार्य वही रहता है: 20 बनाम 40 सेकेंड
इसमें केवल ~14 डीटी जॉइन होते हैं
दो टेबल 30 000 पंक्तियाँ (dt1) और 366 000 पंक्तियाँ (dt2)
15 कॉलम प्रत्येक
कुंजी 2 वर्ण और 1 अंकीय है
और शामिल होने के दौरान 7 फ़ील्ड (dt1 से dt2 तक) असाइन किए गए

मेरा पीसी:
विन 10 64 बिट
एएमडी ए8 2.2 गीगाहर्ट्ज
8 जीबी रैम

cmd: wmic cpu को NumberOfCores, NumberOfLogicalProcessors/ Format:List . मिलता है
नंबरऑफकोर=4
NumberOfLogicalProcessors=4

आपके विश्लेषण के लिए धन्यवाद

हाय @mattdowle तो क्या आप इस पर विचार कर रहे हैं?

एक git bisect के अनुसार मैं अभी फिर से दौड़ा, यह प्रतिबद्धता धीमी गति के लिए "दोषी" है, उम्मीद है कि मैट को जड़ से नीचे पिन करने में मदद मिल सकती है। यह forder से संबंधित है, यह मुझे अपेक्षाकृत विश्वास दिलाता है कि हमने इसे सही ढंग से पिन किया है।

https://github.com/Rdatatable/data.table/commit/e59ba149f21bb35098ed0b527505d5ed6c5cb0db

ज्यादा ठीक:

# run_join_time.sh
R CMD INSTALL . && Rscript time_join.R

# time_join.R
library(data.table)
library(microbenchmark)

aa = data.table(a = seq(1,100), b = rep(0, 100))
bb = data.table(a = seq(1,100), b = rep(1, 100))

summary(microbenchmark(times = 1000L, aa[bb, b := i.b, on=.(a)])$time/1e6)

इन दो लिपियों के साथ, master/HEAD से:

git checkout 1.12.0
git bisect start
git bisect bad
git bisect good 1.11.8

फिर प्रत्येक पुनरावृत्ति पर, sh run_join_time.sh चलाएं और परिणाम जांचें। bad मेरी मशीन पर लगभग .9 सेकंड प्रति पुनरावृत्ति ले रहा था, good लगभग .7 करता है।

हाय माइकल, धन्यवाद, लेकिन विशेष रूप से प्रदर्शन में नाटकीय रूप से गिरावट आई है
कैरेक्टर की- I के लिए पहली पोस्ट में यूनिट टेस्ट दिया गया है
वैसे भी मुझे लगता है कि हमें मैट से पुष्टि की प्रतीक्षा करने की आवश्यकता है कि क्या यह तय है
नया संस्करण या नहीं

गुरु, 26 दिसंबर 2019 को 15:02 बजे, माइकल चिरिको नोटिफिकेशन @github.com
लिखा था:

एक git bisect के अनुसार मैं अभी फिर से भागा, यह कमिट के लिए "दोषी" है
धीमा, उम्मीद है कि मैट को जड़ से नीचे पिन करने में मदद मिल सकती है। वह यह है
forder से संबंधित मुझे अपेक्षाकृत विश्वास दिलाता है कि हमने इसे नीचे पिन कर दिया है
सही ढंग से।

e59ba14
https://github.com/Rdatatable/data.table/commit/e59ba149f21bb35098ed0b527505d5ed6c5cb0db

ज्यादा ठीक:

run_join_time.sh

आर सीएमडी स्थापित करें। && प्रतिलेख time_join.R

time_join.R

पुस्तकालय (डेटा तालिका)
पुस्तकालय (माइक्रोबेंचमार्क)

आ = डेटा। तालिका (ए = सेक (1,100), बी = प्रतिनिधि (0, 100))
बीबी = डेटा। टेबल (ए = सेक (1,100), बी = प्रतिनिधि (1, 100))

सारांश (माइक्रोबेंचमार्क (समय = 1000 एल, आ [बीबी, बी: = आईबी, पर =। (ए)]) $ समय / 1e6)

इन दो लिपियों के साथ, मास्टर/हेड से:

गिट चेकआउट 1.12.0
गिट बाइसेक्ट स्टार्ट
गिट बाइसेक्ट खराब
गिट द्विभाजित अच्छा 1.11.8

फिर प्रत्येक पुनरावृत्ति पर, sh run_join_time.sh चलाएं और परिणाम जांचें।
खराब काम मेरी मशीन पर लगभग .9 सेकंड प्रति पुनरावृत्ति ले रहे थे,
अच्छा काम करता है .7 के बारे में।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/Rdatatable/data.table/issues/3928?email_source=notifications&email_token=ABRM7MJQITNUZDNYV7NTIX3Q2S2ORA5CNFSM4I4ZPREKYY3PNVWWK3TUL52HS4DFVREXG43VMVB4#LOVZHTRNMVXH
या सदस्यता समाप्त करें
https://github.com/notifications/unsubscribe-auth/ABRM7MOTZRFFM2QKVFUHT6LQ2S2ORANCNFSM4I4ZPREA
.

>

सादर,
वसीली कुज़नेत्सोव

@ vk111 यदि यह समस्या बंद नहीं है तो आप सुरक्षित रूप से मान सकते हैं कि समस्या अभी तक ठीक नहीं हुई है। जब भी हम कुछ ठीक करते हैं तो हम संबंधित मुद्दे को बंद कर देते हैं।

@ vk111 आप $#$ setindex $#$ के बजाय setkey का उपयोग करके कुछ मामूली बदलावों को कम करने में सक्षम हो सकते हैं। यह मेरे कंप्यूटर पर आपके परीक्षण को आधे से अधिक कम कर देता है:

aa = data.table(a = seq(1,100), b = rep(0, 100))
bb = data.table(a = seq(1,100), b = rep(1, 100))

aa[,  a1 := as.character(a)]
bb[,  a1 := as.character(a)]

tic()
for(i in c(1:1000)) {
  aa[bb, b := i.b, on=.(a, a1)] # test1 without key
}
toc()
## 4 sec elapsed

tic()
setkey(aa, a, a1)
setkey(bb, a, a1)

for(i in c(1:1000)) {
  aa[bb, b := i.b] # test2 without key
}
toc()
## 1.46 sec elapsed

library(microbenchmark)
library(data.table)

aa = data.table(a = seq(1,100), b = rep(0, 100))
bb = data.table(a = seq(1,100), b = rep(1, 100))

aa[,  a1 := as.character(a)]
bb[,  a1 := as.character(a)]

aa_nokey = copy(aa)
bb_nokey = copy(bb)

tic()
aa_int_key = setkey(copy(aa), a)
bb_int_key = setkey(copy(bb), a)
toc()

tic()
aa_int_char = setkey(copy(aa), a, a1)
bb_int_char = setkey(copy(bb), a, a1)
toc()
int_nokey = function(dt1, dt2){
  dt1[dt2, b := i.b, on=.(a)]
}

int_key = function(dt1, dt2){
  dt1[dt2, b := i.b]
}

int_char_nokey = function(dt1, dt2){
  dt1[dt2, b := i.b, on=.(a, a1)]
}

int_char_key = function(dt1, dt2){
  dt1[dt2, b := i.b]
}

int_char_key_on = function(dt1, dt2){
  dt1[dt2, b := i.b, on=.(a, a1)]
}

boxplot(
  microbenchmark(
    a_no_key = int_nokey(aa, bb),
    a_key = int_key(aa_int_key, bb_int_key),
    a_a1_no_key = int_char_nokey(aa, bb),
    a_a1_key = int_char_key(aa_int_char, bb_int_char),
    a_a1_key_on = int_char_key_on(aa_int_char, bb_int_char)
  )
)

हाय कोल, हाँ मुझे सेटकी के बारे में पता है - मैंने ऊपर संक्षिप्त विवरण दिया है
मेरी परियोजना का और 1000 जुड़ने का कोई उद्देश्य नहीं है - 10-20 . की तरह हैं
जुड़ता है और बात यह है कि मेरे चरित्र तार बहुत गतिशील हैं और I
20 बार सेटकी और 20 की तरह जुड़ने से पहले हर बार सेटकी बनाने की जरूरत है
बार जुड़ता है और इसलिए समय में लाभ 2 गुना से कम है
मैं इस स्थिति के लिए सामान्य समाधान के रूप में थोड़ी देर के लिए 3.4.0 के साथ रहता हूं
और शायद इसे नए संस्करण में ठीक करना कोई बड़ी बात नहीं है, खासकर अगर
एक दोषी प्रतिबद्ध पाया गया है
वैसे अगर हम सेब की तुलना सेब से करें तो मुझे लगता है कि 3.4(1.10) होगा
अभी भी 3.6 (1.12) से तेज है अगर मैं उसी इकाई परीक्षण का उपयोग सेटकी के साथ करता हूं
दोनों संस्करण
छुट्टियों की शुभकामनाएं

सूर्य को, 29 दिसंबर 2019, 14:48 कोल मिलर, नोटिफिकेशन @github.com ने लिखा:

@vk111 https://github.com/vk111 आप कुछ के साथ कम करने में सक्षम हो सकते हैं
सेटइंडेक्स के बजाय सेटकी का उपयोग करके मामूली बदलाव। यह आपके परीक्षण में कटौती करता है
मेरे कंप्यूटर पर आधे से अधिक:

आ = डेटा। तालिका (ए = सेक (1,100), बी = प्रतिनिधि (0, 100))
बीबी = डेटा। टेबल (ए = सेक (1,100), बी = प्रतिनिधि (1, 100))

आ [, a1 := as.character(a)]
bb[, a1 := as.character(a)]

टिक ()
के लिए (मैं सी में (1:1000)) {
एए [बीबी, बी: = आईबी, ऑन =। (ए, ए 1)] # टेस्ट 1 बिना कुंजी
}
टीओसी ()

4 सेकंड बीत गए

टिक ()
सेटकी (एए, ए, ए 1)
सेटकी (बीबी, ए, ए 1)

के लिए (मैं सी में (1:1000)) {
एए [बीबी, बी: = आईबी] # टेस्ट 2 बिना कुंजी
}
टीओसी ()

1.46 सेकंड बीत चुके हैं

[छवि: छवि]
https://user-images.githubusercontent.com/57992489/71557665-126d7880-2a17-11ea-8664-21a10deb47ca.png

पुस्तकालय (माइक्रोबेंचमार्क)
पुस्तकालय (डेटा तालिका)

आ = डेटा। तालिका (ए = सेक (1,100), बी = प्रतिनिधि (0, 100))
बीबी = डेटा। टेबल (ए = सेक (1,100), बी = प्रतिनिधि (1, 100))

आ [, a1 := as.character(a)]
bb[, a1 := as.character(a)]

आ_नोकी = कॉपी (एए)
bb_nokey = कॉपी (बीबी)

टिक ()
एए_इंट_की = सेटकी (कॉपी (एए), ए)
bb_int_key = सेटकी (कॉपी (बीबी), ए)
टीओसी ()

टिक ()
एए_इंट_चार = सेटकी (कॉपी (एए), ए, ए 1)
bb_int_char = सेटकी (कॉपी (बीबी), ए, ए 1)
टीओसी ()
int_nokey = फ़ंक्शन (डीटी 1, डीटी 2) {
डीटी 1 [डीटी 2, बी: = आईबी, पर =। (ए)]
}

int_key = फ़ंक्शन (डीटी 1, डीटी 2) {
डीटी 1 [डीटी 2, बी: = आईबी]
}

int_char_nokey = फ़ंक्शन (डीटी 1, डीटी 2) {
डीटी 1 [डीटी 2, बी: = आईबी, पर =। (ए, ए 1)]
}

int_char_key = फ़ंक्शन (डीटी 1, डीटी 2) {
डीटी 1 [डीटी 2, बी: = आईबी]
}

int_char_key_on = फ़ंक्शन (डीटी 1, डीटी 2) {
डीटी 1 [डीटी 2, बी: = आईबी, पर =। (ए, ए 1)]
}

बॉक्स प्लॉट(
माइक्रोबेंचमार्क (
a_no_key = int_nokey (आ, बीबी),
a_key = int_key (aa_int_key, bb_int_key),
a_a1_no_key = int_char_nokey (आ, बीबी),
a_a1_key = int_char_key(aa_int_char, bb_int_char),
a_a1_key_on = int_char_key_on(aa_int_char, bb_int_char)
)
)

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/Rdatatable/data.table/issues/3928?email_source=notifications&email_token=ABRM7MPU64YBK7UNT3O3OYDQ3CTBRA5CNFSM4I4ZPREKYY3PNVWWK3TUL52HS4DFVREXG43VMVB72#JIZGOTNV56H
या सदस्यता समाप्त करें
https://github.com/notifications/unsubscribe-auth/ABRM7MKSP6LCUJD2HOAG7D3Q3CTRANCNFSM4I4ZPREA
.

एक लंबित पीआर #4370 है जो संबंधित है। यह कम ओवरहेड के साथ जुड़ सकता है जो सामान्य रूप से [ लगाता है। यह आपके उदाहरण के समय को 2 के कारक से कम करता है। डेटा जितना बड़ा होगा, सुधार उतना ही छोटा होगा, लेकिन दूसरी ओर, अधिक पुनरावृत्तियों, बेहतर सुधार। ध्यान दें कि शामिल होने के दौरान कॉलम को अपडेट करने का कोई तरीका नहीं है। आपको मूल रूप से शामिल होने के दौरान कॉलम जोड़ना होगा, और फिर fcoalesce जैसे कुछ का उपयोग करना होगा, लेकिन यह प्रदर्शनकारी होना चाहिए।
एक बार #4386 का भी विलय हो जाने के बाद इसे कुछ अतिरिक्त गति मिलनी चाहिए।

library(data.table)
aa = data.table(a = seq(1,100), b = rep(0, 100))
bb = data.table(a = seq(1,100), b = rep(1, 100))
setindex(aa, a)
setindex(bb, a)
p = proc.time()[[3L]]
for (i in c(1:1000)) {
  aa[bb, b := i.b, on=.(a)]
}
proc.time()[[3L]]-p
#[1] 1.1

मर्जलिस्ट #4370

library(data.table)
aa = data.table(a = seq(1,100), b = rep(0, 100))
bb = data.table(a = seq(1,100), b = rep(1, 100))
setindex(aa, a)
setindex(bb, a)
p = proc.time()[[3L]]
for (i in c(1:1000)) {
  mergelist(list(aa, bb), on="a")
}
proc.time()[[3L]]-p
#[1] 0.696

हाय जान, ठीक है धन्यवाद

डेटा जितना बड़ा होगा, सुधार उतना ही छोटा होगा, लेकिन दूसरी ओर,
अधिक पुनरावृत्तियों, बेहतर सुधार
असली मुद्दा बड़े डेटा और कुछ पुनरावृत्तियों से संबंधित है - मैंने इसे लिखा था
के ऊपर

सोम, 4 मई 2020, 00:33 जन गोरेकी को, नोटिफिकेशन @github.com ने लिखा:

एक लंबित जनसंपर्क है #4370
https://github.com/Rdatatable/data.table/pull/4370 जो संबंधित है। यह
कम ओवरहेड के साथ जुड़ सकते हैं जो [सामान्य रूप से लगाता है। यह को कम करता है
2 के कारक द्वारा आपके उदाहरण का समय। जितना बड़ा डेटा, उतना छोटा
सुधार, लेकिन दूसरी ओर, अधिक पुनरावृत्तियों, बेहतर
सुधार की। ध्यान दें कि शामिल होने के दौरान कॉलम को अपडेट करने का कोई तरीका नहीं है। आप
मूल रूप से शामिल होने के दौरान कॉलम जोड़ना होता है, और फिर कुछ ऐसा उपयोग करना होता है
fcoalesce, लेकिन वह प्रदर्शनकारी होना चाहिए।
इसे #4386 . के बाद कुछ अतिरिक्त गति मिलनी चाहिए
https://github.com/Rdatatable/data.table/pull/4386 को भी मर्ज किया जाएगा।

पुस्तकालय (डेटा। तालिका) आ = डेटा। तालिका (ए = सेक (1,100), बी = प्रतिनिधि (0, 100)) बीबी = डेटा। तालिका (ए = सेक (1,100), बी = प्रतिनिधि (1, 100))
सेटइंडेक्स (एए, ए)
setindex(bb, a)p = proc.time()[[3L]]for (i in c(1:1000)) {
आ [बीबी, बी: = आईबी, पर =। (ए)]
}
proc.time()[[3L]]-p#[1] 1.1

मर्जलिस्ट #4370 https://github.com/Rdatatable/data.table/pull/4370

पुस्तकालय (डेटा। तालिका) आ = डेटा। तालिका (ए = सेक (1,100), बी = प्रतिनिधि (0, 100)) बीबी = डेटा। तालिका (ए = सेक (1,100), बी = प्रतिनिधि (1, 100))
सेटइंडेक्स (एए, ए)
setindex(bb, a)p = proc.time()[[3L]]for (i in c(1:1000)) {
मर्जलिस्ट (सूची (एए, बीबी), ऑन = "ए")
}
proc.time()[[3L]]-p#[1] 0.696

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/Rdatatable/data.table/issues/3928#issuecomment-623193573 ,
या सदस्यता समाप्त करें
https://github.com/notifications/unsubscribe-auth/ABRM7MJR5THRHE3FIXXV3YTRPXWNNANCNFSM4I4ZPREA
.

मैंने जाँच की कि क्या #4440 (कल विलय) इस मुद्दे को हल करता है, लेकिन ऐसा लगता है कि ऐसा नहीं है। हालांकि मुझे यहां मिलने वाला समय @vk111 द्वारा रिपोर्ट किए गए समय से काफी अलग है, इसलिए यदि आप हाल के विकास संस्करण का परीक्षण करने में सक्षम हैं, और देखें कि क्या इससे आपके वर्कफ़्लो के लिए कोई फर्क पड़ता है जो मददगार होगा।
जैसा कि आप विंडोज़ पर हैं, एक और लंबित पीआर है जो अंततः # 4558 में मदद कर सकता है।

यह सामान्य स्क्रिप्ट है जिसे मैं प्रत्येक वातावरण में चलाता हूं:

library(data.table)
setDTthreads(2) ## vk111 has 4 cores
aa = data.table(a = seq(1,100), b = rep(0, 100))[,  a1 := as.character(a)]
bb = data.table(a = seq(1,100), b = rep(1, 100))[,  a1 := as.character(a)]
setindex(aa, a); setindex(bb, a)
cat("test1\n")
system.time({
for(i in c(1:1000)) {
  aa[bb, b := i.b, on=.(a, a1)] # test1
}})
cat("test2\n")
system.time({
for(i in c(1:1000)) {
  aa[bb, b := i.b, on=.(a)] # test2
}})

और ये वातावरण हैं:

docker run -it --rm r-base:3.4.0
install.packages("https://cran.r-project.org/src/contrib/Archive/data.table/data.table_1.10.4-3.tar.gz", repos=NULL)
test1
   user  system elapsed 
  0.949   0.007   0.957 
test2
   user  system elapsed 
  0.864   0.000   0.864 

docker run -it --rm r-base:3.6.1
install.packages("https://cran.r-project.org/src/contrib/Archive/data.table/data.table_1.12.2.tar.gz", repos=NULL)
test1
   user  system elapsed 
  2.598   0.047   1.350 
test2
   user  system elapsed 
  2.092   0.016   1.062 



md5-e82041eef8382e88332d077bb608b87c



docker run -it --rm r-base:3.6.1
install.packages("data.table", repos="https://Rdatatable.gitlab.io/data.table")
test1
   user  system elapsed 
  1.174   0.045   1.219 
test2
   user  system elapsed 
  0.981   0.024   1.004 

नमस्ते, मैं विंडोज़ पर हूँ

शुक्रवार, 26 जून 2020, 13:19 जनवरी गोरेकी को, नोटिफिकेशन @github.com ने लिखा:

मैंने जाँच की कि क्या #4440 https://github.com/Rdatatable/data.table/pull/4440
इस मुद्दे को हल करें, लेकिन ऐसा लगता है कि ऐसा नहीं हुआ। हालांकि समय मुझे मिल रहा है
यहां @vk111 . द्वारा बताए गए समय से काफी अलग हैं
https://github.com/vk111 , इसलिए यदि आप हाल के विकास का परीक्षण करने में सक्षम हैं
संस्करण, और देखें कि क्या इससे आपके वर्कफ़्लो के लिए कोई फर्क पड़ता है जो होगा
मददगार।
यह सामान्य स्क्रिप्ट है जिसे मैं प्रत्येक वातावरण में चलाता हूं:

पुस्तकालय (डेटा तालिका)
setDTthreads(2) ## vk111 में 4 coresaa = data.table(a = seq(1,100), b = rep(0, 100))[, a1:= as.character(a)]bb = data.table(a) है = seq(1,100), b = rep(1, 100))[, a1 := as.character(a)]
सेटइंडेक्स (एए, ए); सेटइंडेक्स (बीबी, ए)
बिल्ली ("test1n")
system.time({for(i in c(1:1000)) {
एए [बीबी, बी: = आईबी, पर =। (ए, ए 1)] # टेस्ट 1
}})
बिल्ली ("test2n")
system.time({for(i in c(1:1000)) {
आ [बीबी, बी: = आईबी, पर =। (ए)] # परीक्षण 2
}})

और ये वातावरण हैं:

डॉकर रन-इट --आरएम आर- बेस: 3.4.0
install.packages("https://cran.r-project.org/src/contrib/Archive/data.table/data.table_1.10.4-3.tar.gz", repos=NULL)
टेस्ट1
उपयोगकर्ता प्रणाली समाप्त हो गई
0.949 0.007 0.957
टेस्ट2
उपयोगकर्ता प्रणाली समाप्त हो गई
0.864 0.000 0.864

डॉकर रन-इट --आरएम आर- बेस:3.6.1
install.packages("https://cran.r-project.org/src/contrib/Archive/data.table/data.table_1.12.2.tar.gz", repos=NULL)
टेस्ट1
उपयोगकर्ता प्रणाली समाप्त हो गई
2.598 0.047 1.350
टेस्ट2
उपयोगकर्ता प्रणाली समाप्त हो गई
2.092 0.016 1.062

डॉकर रन-इट --आरएम आर- बेस:3.6.1
install.packages("data.table", repos="https://Rdatatable.gitlab.io/data.table")
टेस्ट1
उपयोगकर्ता प्रणाली समाप्त हो गई
1.174 0.045 1.219
टेस्ट2
उपयोगकर्ता प्रणाली समाप्त हो गई
0.981 0.024 1.004

जैसा कि आप विंडोज़ पर हैं, एक और लंबित पीआर है जो अंततः हो सकता है
मदद #4558 https://github.com/Rdatatable/data.table/pull/4558 ।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/Rdatatable/data.table/issues/3928#issuecomment-650126662 ,
या सदस्यता समाप्त करें
https://github.com/notifications/unsubscribe-auth/ABRM7MJLU3XRN5YN37ZVLALRYR727ANCNFSM4I4ZPREA
.

@ vk111 हाँ, ठीक वही जो मैं पूछ रहा था। यदि आप अपने विंडोज मशीन पर उन 3 विन्यासों की जांच कर सकते हैं और देख सकते हैं कि आपके लिए कोई प्रगति हुई है या नहीं।

लेकिन जैसा कि मैंने समझा था कि विंडोज़ के लिए पीआर अभी तक विलय नहीं हुआ है

शुक्र, 26 जून 2020, 20:07 जनवरी गोरेकी को, नोटिफिकेशन @github.com ने लिखा:

@vk111 https://github.com/vk111 हां, ठीक वही जो मैं पूछ रहा था।
यदि आप अपने विंडोज मशीन पर उन 3 विन्यासों की जांच कर सकते हैं और देखें
अगर आपके लिए कोई प्रगति है।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/Rdatatable/data.table/issues/3928#issuecomment-650320224 ,
या सदस्यता समाप्त करें
https://github.com/notifications/unsubscribe-auth/ABRM7MMDOCNAWARCCDRSU23RYTPVFANCNFSM4I4ZPREA
.

4440 पहले ही मर्ज हो चुका है और हर ओएस के लिए मदद करता है। #4558 अभी भी विलय के लिए लंबित है।

@vk111 #4558 को पहले ही मर्ज कर दिया गया है

हाय जान, मैंने हाल ही में आपकी सलाह ली - #4419
https://github.com/Rdatatable/data.table/issues/4419 मेरे मुद्दे से संबंधित
इसलिए मेरे पास वर्णों के साथ कोड का यह सटीक टुकड़ा नहीं है
लेकिन वैसे भी इस सुधार के लिए धन्यवाद, मुझे यकीन है कि इससे बहुत मदद मिलेगी
भविष्य में लोग अगर आपको लगता है कि इसका प्रदर्शन बेहतर है तो I
लगता है कि आपको बस इसे मर्ज करना चाहिए
आपको धन्यवाद

अक्टूबर, 26 अप्रैल। 2020 . 20:29 जनवरी, गोरेकी सूचनाएं @github.com:

4440 https://github.com/Rdatatable/data.table/pull/4440 पहले से ही है

विलय और हर ओएस के लिए मदद। #4558
https://github.com/Rdatatable/data.table/pull/4558 अभी भी लंबित है
विलय

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/Rdatatable/data.table/issues/3928#issuecomment-650330154 ,
या सदस्यता समाप्त करें
https://github.com/notifications/unsubscribe-auth/ABRM7MIN2P7BXMKG74Z7EKTRYTSIJANCNFSM4I4ZPREA
.

--
सादर,
वसीली कुज़नेत्सोव

@vk111 उल्लेखित पीआर पहले ही मर्ज किए जा चुके हैं। बात यह जानने की है कि क्या यह समस्या हल हो गई है, या कम से कम सुधार हुआ है। वे मर्ज किए गए पीआर इस मुद्दे को हल करने का प्रयास नहीं कर रहे थे, लेकिन वे संबंधित हैं इसलिए वे मददगार हो सकते हैं।

ऐसा होता है कि शुरू में रिपोर्ट किया गया न्यूनतम उदाहरण इस मुद्दे को खराब तरीके से उजागर कर रहा था। @vk111 https://github.com/Rdatatable/data.table/issues/3928#issuecomment -538681316 के आधार पर मैंने एक्समैपल का निर्माण किया जो स्पष्ट रूप से दिखाता है कि यहां कोई समस्या है।

install.packages("https://cran.r-project.org/src/contrib/Archive/data.table/data.table_1.10.4-3.tar.gz", repos=NULL)
install.packages("https://cran.r-project.org/src/contrib/Archive/data.table/data.table_1.12.2.tar.gz", repos=NULL)
install.packages("data.table", repos="https://Rdatatable.gitlab.io/data.table")

library(data.table)
setDTthreads(2L)
set.seed(108)
n2 = 1:366000
n1 = sample(n2, 30000)
d1=data.table(id1=paste0("id",sample(n1)), id2=paste0("id",sample(n1)), v1=n1)
d2=data.table(id1=paste0("id",sample(n2)), id2=paste0("id",sample(n2)), v2=n2)
system.time(d2[d1, v1 := i.v1, on=c("id1","id2")])



md5-e82041eef8382e88332d077bb608b87c



# 3.4.0: 1.10.4-3
   user  system elapsed 
  0.144   0.000   0.144 
# 3.4.0: 1.12.2
   user  system elapsed 
  0.611   0.003   0.451 
# 3.4.0: 1.12.9
   user  system elapsed 
  0.611   0.000   0.452 



md5-e82041eef8382e88332d077bb608b87c



# 4.0.0: 1.10.4-3
   user  system elapsed 
  0.203   0.008   0.211 
# 4.0.0: 1.12.9
   user  system elapsed 
  0.812   0.004   0.644 

वर्बोज़ से पता चलता है कि अधिकांश समय Calculated ad hoc index in 0.611s elapsed (0.769s cpu) व्यतीत होता है, जिसे bmerge से bmerge forderv पर कॉल किया जाता है।

हाँ बिल्कुल
लेकिन ऐसा लगता है कि इस परीक्षण में कोई सुधार नहीं हुआ है?

मंगलवार, 30 जून 2020, 00:45 जनवरी गोरेकी, नोटिफिकेशन @github.com ने लिखा:

ऐसा होता है कि शुरू में रिपोर्ट किया गया न्यूनतम उदाहरण खराब रूप से उजागर हो रहा था
समस्या। @vk111 https://github.com/vk111 #3928 पर आधारित (टिप्पणी)
https://github.com/Rdatatable/data.table/issues/3928#issuecomment-538681316
मैंने उदाहरण का निर्माण किया जो स्पष्ट रूप से दिखाता है कि यहां कोई समस्या है।

पुस्तकालय (डेटा तालिका)
सेट डीटीथ्रेड्स (2 एल)
set.seed(108)n2 = 1:366000n1 = नमूना (n2, 30000)d1=data.table(id1=paste0("id",sample(n1)), id2=paste0("id",sample(n1) ), v1=n1)d2=data.table(id1=paste0("id",sample(n2)), id2=paste0("id",sample(n2)), v2=n2)
system.time(d2[d1, v1:= i.v1, on=c("id1",,"id2")])

3.4.0: 1.10.4-3

उपयोगकर्ता प्रणाली समाप्त हो गई
0.144 0.000 0.144

3.4.0: 1.12.2

उपयोगकर्ता प्रणाली समाप्त हो गई
0.611 0.003 0.451

3.4.0: 1.12.9

उपयोगकर्ता प्रणाली समाप्त हो गई
0.611 0.000 0.452

4.0.0: 1.12.9

उपयोगकर्ता प्रणाली समाप्त हो गई
0.812 0.004 0.644

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/Rdatatable/data.table/issues/3928#issuecomment-651408089 ,
या सदस्यता समाप्त करें
https://github.com/notifications/unsubscribe-auth/ABRM7MPQHSOEGLXS625BU3TRZEKSBANCNFSM4I4ZPREA
.

कोई सुधार नहीं, यह अभी भी एक मुद्दा है।
कुछ खुदाई के बाद मैंने पाया कि अड़चन यह कॉल है
https://github.com/Rdatatable/data.table/blob/ba32f3cba38ec270587e395f6e6c26a80be36be6/src/forder.c#L282
आगे बढ़ना...
यह लूप 60% के लिए जिम्मेदार है
https://github.com/Rdatatable/data.table/blob/ba32f3cba38ec270587e395f6e6c26a80be36be6/src/forder.c#L242 -L245
और वे 30% के लिए
https://github.com/Rdatatable/data.table/blob/ba32f3cba38ec270587e395f6e6c26a80be36be6/src/forder.c#L252 -L258

मैंने यह जांचने की कोशिश की कि क्या आर इंटर्नल्स ( CHAR() फ़ंक्शन के बजाय मैक्रो) का उपयोग करने से यहां मदद मिलेगी, लेकिन यह मदद नहीं करता है।

और भी न्यूनतम उदाहरण, केवल forderv समय, केवल R 4.0 पर

install.packages("https://cran.r-project.org/src/contrib/Archive/data.table/data.table_1.10.4-3.tar.gz", repos=NULL)
library(data.table)
setDTthreads(1L)
set.seed(108)
n2 = 1:366000
d2=data.table(id1=paste0("id",sample(n2)), id2=paste0("id",sample(n2)), v2=n2)
system.time(data.table:::forderv(d2, c("id1","id2")))

install.packages("data.table", repos="https://Rdatatable.gitlab.io/data.table")
library(data.table)
setDTthreads(1L)
set.seed(108)
n2 = 1:366000
d2=data.table(id1=paste0("id",sample(n2)), id2=paste0("id",sample(n2)), v2=n2)
system.time(data.table:::forderv(d2, c("id1","id2")))



md5-e82041eef8382e88332d077bb608b87c



# 4.0.2: 1.10.4-3
   user  system elapsed 
  0.198   0.000   0.198 
# 4.0.2: 1.12.9
   user  system elapsed 
  0.393   0.000   0.392 

मैंने यह जाँचने की कोशिश की कि क्या R इंटर्नल (CHAR() फ़ंक्शन के बजाय मैक्रो) का उपयोग करने से यहाँ मदद मिलेगी, लेकिन यह मदद नहीं करता है।

ऐसा इसलिए है क्योंकि R अब ऐसा नहीं करता है। USE_RINTERNALS के साथ, INTEGER, REAL और मैं CHAR भी मानता हूं, अभी भी इनलाइन फ़ंक्शन हैं। दूसरे शब्दों में, USE_RINTERNALS के लाभ (अर्थात फ़ंक्शन के बजाय मैक्रो) को ALTREP की अनुमति देने के लिए R के हाल के संस्करणों में हटा दिया गया था। मुझे विश्वास नहीं है कि यह वास्तव में है कि यह मैक्रो या फ़ंक्शन या इनलाइन फ़ंक्शन है, प्रति से, इससे फर्क पड़ता है। यह कार्य की उस इकाई के अंदर R द्वारा किया जा रहा है। पुराने दिनों में, USE_RINTERNALS ने इसे एक मैक्रो बना दिया था और यह एक डायरेक्ट मेमोरी लुकअप था (वेक्टर के हेडर को ध्यान में रखते हुए एक सरणी डीरेफरेंस) यही कारण है कि यह तेज़ था। यह काम की एक बहुत ही हल्की इकाई थी। इन दिनों, आर के पास ALTREP की जांच करने के लिए कम से कम एक शाखा है और, यहां तक ​​कि शाखा भविष्यवाणी के साथ, कि अतिरिक्त काम जुड़ जाता है और/या प्रीफेच को रोकता है। दूसरे शब्दों में, इन इनलाइन फ़ंक्शंस के अंदर R के पास अब थोड़ा और कोड है। मेरे पास कोई बेंचमार्क सबूत नहीं है, बस इसे देखने के आधार पर सिद्धांत है।

मूल कारण cradix_r . में निम्नलिखित शाखा को हटाना हो सकता है
https://github.com/Rdatatable/data.table/blob/76bb569fd7736b5f89471a35357e6a971ae1d424/src/forder.c#L780 -L783
और अब लंबाई 2 के इनपुट के लिए कोई शॉर्ट-सर्किट नहीं है।
यह स्पष्ट नहीं है कि अब उस शाखा को कैसे रखा जाए क्योंकि कार्य कैसे संचालित होता है, इसके संदर्भ में कार्य बहुत बदल गया है।