मैं फ़ाइल (बाइनरी या टेक्स्ट) की प्रतिलिपि बनाने के लिए एक अच्छा तरीका खोजता हूं। मैंने कई नमूने लिखे हैं, हर कोई काम करता है। लेकिन मैं अनुभवी प्रोग्रामरों की राय सुनना चाहता हूं।
मुझे अच्छे उदाहरण याद आ रहे हैं और एक ऐसा तरीका खोज रहे हैं जो C ++ के साथ काम करता है।
एएनएसआई-सी-तरफा
#include <iostream>
#include <cstdio> // fopen, fclose, fread, fwrite, BUFSIZ
#include <ctime>
using namespace std;
int main() {
clock_t start, end;
start = clock();
// BUFSIZE default is 8192 bytes
// BUFSIZE of 1 means one chareter at time
// good values should fit to blocksize, like 1024 or 4096
// higher values reduce number of system calls
// size_t BUFFER_SIZE = 4096;
char buf[BUFSIZ];
size_t size;
FILE* source = fopen("from.ogv", "rb");
FILE* dest = fopen("to.ogv", "wb");
// clean and more secure
// feof(FILE* stream) returns non-zero if the end of file indicator for stream is set
while (size = fread(buf, 1, BUFSIZ, source)) {
fwrite(buf, 1, size, dest);
}
fclose(source);
fclose(dest);
end = clock();
cout << "CLOCKS_PER_SEC " << CLOCKS_PER_SEC << "\n";
cout << "CPU-TIME START " << start << "\n";
cout << "CPU-TIME END " << end << "\n";
cout << "CPU-TIME END - START " << end - start << "\n";
cout << "TIME(SEC) " << static_cast<double>(end - start) / CLOCKS_PER_SEC << "\n";
return 0;
}POSIX-WAY (K & R इसका उपयोग "द C प्रोग्रामिंग लैंग्वेज" में करते हैं, अधिक निम्न-स्तर)
#include <iostream>
#include <fcntl.h> // open
#include <unistd.h> // read, write, close
#include <cstdio> // BUFSIZ
#include <ctime>
using namespace std;
int main() {
clock_t start, end;
start = clock();
// BUFSIZE defaults to 8192
// BUFSIZE of 1 means one chareter at time
// good values should fit to blocksize, like 1024 or 4096
// higher values reduce number of system calls
// size_t BUFFER_SIZE = 4096;
char buf[BUFSIZ];
size_t size;
int source = open("from.ogv", O_RDONLY, 0);
int dest = open("to.ogv", O_WRONLY | O_CREAT /*| O_TRUNC/**/, 0644);
while ((size = read(source, buf, BUFSIZ)) > 0) {
write(dest, buf, size);
}
close(source);
close(dest);
end = clock();
cout << "CLOCKS_PER_SEC " << CLOCKS_PER_SEC << "\n";
cout << "CPU-TIME START " << start << "\n";
cout << "CPU-TIME END " << end << "\n";
cout << "CPU-TIME END - START " << end - start << "\n";
cout << "TIME(SEC) " << static_cast<double>(end - start) / CLOCKS_PER_SEC << "\n";
return 0;
}KISS-सी ++ - Streambuffer-तरफा
#include <iostream>
#include <fstream>
#include <ctime>
using namespace std;
int main() {
clock_t start, end;
start = clock();
ifstream source("from.ogv", ios::binary);
ofstream dest("to.ogv", ios::binary);
dest << source.rdbuf();
source.close();
dest.close();
end = clock();
cout << "CLOCKS_PER_SEC " << CLOCKS_PER_SEC << "\n";
cout << "CPU-TIME START " << start << "\n";
cout << "CPU-TIME END " << end << "\n";
cout << "CPU-TIME END - START " << end - start << "\n";
cout << "TIME(SEC) " << static_cast<double>(end - start) / CLOCKS_PER_SEC << "\n";
return 0;
}कॉपी-एल्गोरिथ्म-सी ++ - रास्ता
#include <iostream>
#include <fstream>
#include <ctime>
#include <algorithm>
#include <iterator>
using namespace std;
int main() {
clock_t start, end;
start = clock();
ifstream source("from.ogv", ios::binary);
ofstream dest("to.ogv", ios::binary);
istreambuf_iterator<char> begin_source(source);
istreambuf_iterator<char> end_source;
ostreambuf_iterator<char> begin_dest(dest);
copy(begin_source, end_source, begin_dest);
source.close();
dest.close();
end = clock();
cout << "CLOCKS_PER_SEC " << CLOCKS_PER_SEC << "\n";
cout << "CPU-TIME START " << start << "\n";
cout << "CPU-TIME END " << end << "\n";
cout << "CPU-TIME END - START " << end - start << "\n";
cout << "TIME(SEC) " << static_cast<double>(end - start) / CLOCKS_PER_SEC << "\n";
return 0;
}स्वयं-बफर-सी ++ - रास्ता
#include <iostream>
#include <fstream>
#include <ctime>
using namespace std;
int main() {
clock_t start, end;
start = clock();
ifstream source("from.ogv", ios::binary);
ofstream dest("to.ogv", ios::binary);
// file size
source.seekg(0, ios::end);
ifstream::pos_type size = source.tellg();
source.seekg(0);
// allocate memory for buffer
char* buffer = new char[size];
// copy file
source.read(buffer, size);
dest.write(buffer, size);
// clean up
delete[] buffer;
source.close();
dest.close();
end = clock();
cout << "CLOCKS_PER_SEC " << CLOCKS_PER_SEC << "\n";
cout << "CPU-TIME START " << start << "\n";
cout << "CPU-TIME END " << end << "\n";
cout << "CPU-TIME END - START " << end - start << "\n";
cout << "TIME(SEC) " << static_cast<double>(end - start) / CLOCKS_PER_SEC << "\n";
return 0;
}LINUX-WAY // को कर्नेल> = 2.6.33 की आवश्यकता है
#include <iostream>
#include <sys/sendfile.h> // sendfile
#include <fcntl.h> // open
#include <unistd.h> // close
#include <sys/stat.h> // fstat
#include <sys/types.h> // fstat
#include <ctime>
using namespace std;
int main() {
clock_t start, end;
start = clock();
int source = open("from.ogv", O_RDONLY, 0);
int dest = open("to.ogv", O_WRONLY | O_CREAT /*| O_TRUNC/**/, 0644);
// struct required, rationale: function stat() exists also
struct stat stat_source;
fstat(source, &stat_source);
sendfile(dest, source, 0, stat_source.st_size);
close(source);
close(dest);
end = clock();
cout << "CLOCKS_PER_SEC " << CLOCKS_PER_SEC << "\n";
cout << "CPU-TIME START " << start << "\n";
cout << "CPU-TIME END " << end << "\n";
cout << "CPU-TIME END - START " << end - start << "\n";
cout << "TIME(SEC) " << static_cast<double>(end - start) / CLOCKS_PER_SEC << "\n";
return 0;
}वातावरण
- GNU / LINUX (Archlinux)
- कर्नेल ३.३
- GLIBC-2.15, LIBSTDC ++ 4.7 (GCC-LIBS), GCC 4.7, Coreutils 8.16
- RUNLEVEL 3 (बहुउपयोगकर्ता, नेटवर्क, टर्मिनल, कोई GUI) का उपयोग करना
- SSD-Postville 80 GB, 50% तक भरा
- एक 270 एमबी ओजीजी-वीडियो-कॉपी की प्रतिलिपि बनाएँ
प्रजनन करने कि प्रक्रिया
1. $ rm from.ogg
2. $ reboot # kernel and filesystem buffers are in regular
3. $ (time ./program) &>> report.txt # executes program, redirects output of program and append to file
4. $ sha256sum *.ogv # checksum
5. $ rm to.ogg # remove copy, but no sync, kernel and fileystem buffers are used
6. $ (time ./program) &>> report.txt # executes program, redirects output of program and append to fileपरिणाम (CPU समय का उपयोग)
Program Description UNBUFFERED|BUFFERED
ANSI C (fread/frwite) 490,000|260,000
POSIX (K&R, read/write) 450,000|230,000
FSTREAM (KISS, Streambuffer) 500,000|270,000
FSTREAM (Algorithm, copy) 500,000|270,000
FSTREAM (OWN-BUFFER) 500,000|340,000
SENDFILE (native LINUX, sendfile) 410,000|200,000 फ़ाइलें बदलना नहीं है।
sha256sum समान परिणाम प्रिंट करते हैं।
वीडियो फ़ाइल अभी भी खेलने योग्य है।
प्रशन
- आप किस विधि को प्राथमिकता देंगे?
- क्या आप बेहतर उपाय जानते हैं?
- क्या आपको मेरे कोड में कोई गलतियाँ दिखती हैं?
क्या आप समाधान से बचने का एक कारण जानते हैं?
FSTREAM (KISS, Streambuffer)
मैं वास्तव में इस तरह, क्योंकि यह वास्तव में छोटे और सरल है। जहां तक मुझे पता है कि ऑपरेटर << rdbuf () के लिए अतिभारित है और कुछ भी परिवर्तित नहीं करता है। सही बात?
धन्यवाद
अद्यतन 1
मैंने उस तरह से सभी नमूनों में स्रोत को बदल दिया, कि घड़ी के मापक में फ़ाइल डिस्क्रिप्टर का खुला और बंद होना शामिल है । उनके स्रोत कोड में कोई अन्य महत्वपूर्ण बदलाव नहीं हैं। परिणाम नहीं बदले! मैंने अपने परिणामों को दोबारा जांचने के लिए समय का उपयोग किया ।
अद्यतन 2
एएनएसआई सी नमूना बदल गया: लूप की स्थिति किसी भी लंबे समय तक फ़ॉफ़ () नहीं कहती है इसके बजाय मैं फ़्रेड ले गया () हालत में। ऐसा लगता है, कोड अब 10,000 घड़ियों को तेजी से चलाता है।
माप बदल गया: पूर्व परिणाम हमेशा बफ़र किए गए थे, क्योंकि मैंने पुरानी कमांड लाइन rm to.ogv && सिंक और& time ./program को प्रत्येक प्रोग्राम के लिए कुछ समय में दोहराया था । अब मैं हर प्रोग्राम के लिए सिस्टम को रिबूट करता हूं। असंबद्ध परिणाम नए हैं और कोई आश्चर्य नहीं दिखाते हैं। असंबद्ध परिणाम वास्तव में नहीं बदले।
यदि मैं पुरानी प्रति नहीं हटाता हूं, तो प्रोग्राम अलग-अलग प्रतिक्रिया देते हैं। किसी मौजूदा फ़ाइल को अधिलेखित करना POSIX और SENDFILE के साथ बफ़र किया गया है, अन्य सभी प्रोग्राम धीमे हैं। हो सकता है कि विकल्प काट - छाँट या बनाने से इस व्यवहार पर असर पड़े। लेकिन एक ही कॉपी के साथ मौजूदा फ़ाइलों को अधिलेखित करना वास्तविक दुनिया का उपयोग-मामला नहीं है।
प्रतिलिपि cp के साथ प्रदर्शन करने में 0.44 सेकंड लगते हैं, 0. 0.30 सेकंड बिना बफ़र किए हुए। तो POSIX नमूने की तुलना में cp थोड़ा धीमा है। मेरे लिए ठीक लग रहा है।
हो सकता है कि मैं mmap () और copy_file()बूस्ट :: filesystem के नमूने और परिणाम भी जोड़ दूं ।
अपडेट 3
मैंने इसे ब्लॉग पेज पर भी डाल दिया है और इसे थोड़ा बढ़ा दिया है। जिसमें स्प्लिस () शामिल है , जो लिनक्स कर्नेल से एक निम्न-स्तरीय फ़ंक्शन है। शायद जावा के साथ अधिक नमूने का पालन करेंगे।
http://www.ttyhoney.com/blog/?page_id=69
#include <copyfile.h> copyfile(const char *from, const char *to, copyfile_state_t state, copyfile_flags_t flags);
fstreamनिश्चित रूप से फ़ाइल संचालन के लिए एक अच्छा विकल्प है।