我试图通过附加文件,在同一个密钥下将多个文件上传到Amazon S3.我有一个文件名列表,并希望按该顺序上传/追加文件.我几乎完全遵循本教程,但我首先循环遍历每个文件并部分上传.因为文件在hdfs上(Path实际上是org.apache.hadoop.fs.Path),所以我使用输入流来发送文件数据.下面是一些伪代码(我正在评论教程中逐字逐句的块):
// Create a list of UploadPartResponse objects. You get one of these for
// each part upload.
List<PartETag> partETags = new ArrayList<PartETag>();
// Step 1: Initialize.
InitiateMultipartUploadRequest initRequest = new InitiateMultipartUploadRequest(
bk.getBucket(), bk.getKey());
InitiateMultipartUploadResult initResponse =
s3Client.initiateMultipartUpload(initRequest);
try {
int i = 1; // part number
for (String file : files) {
Path filePath = new Path(file);
// Get the input stream and content length
long contentLength = fss.get(branch).getFileStatus(filePath).getLen();
InputStream is = fss.get(branch).open(filePath);
long filePosition = …我有下面列出的 4 个源文件：
//a.h
#pragma once
namespace proj {
class A {} a;
} // namespace proj
//b.h
#pragma once
namespace proj {
int foo();
} // namespace proj
// b.cpp
#include "proj/a.h"
namespace proj {
int foo() {
A b = a;
return 0;
}
} // namespace proj
// c.cpp
#include "proj/a.h"
#include "proj/b.h"
using namespace proj;
int main() {
A b = a;
foo();
return 0;
}
当我尝试编译时，c.cpp出现以下链接错误：
duplicate symbol proj::a in:
buck-out/gen/proj/c#compile-c.cpp.ob5f76e97,default/c.cpp.o
buck-out/gen/proj/b#default,static/libb.a(b.cpp.o)
duplicate …我对L1缓存的理解是内存提取加载了缓存行.假设高速缓存行大小为64个字节,如果我在地址访问存储器p,它将从加载整个块p到p + 64到缓存中.因此,最好从左到右(而不是从右到左)迭代一个数组,以最大化缓存局部性.
但是,我编写了一个示例C代码,它分配了一个包含1亿个字符的数组,将随机值写入其中并对其求和(下面复制以供参考).一个版本的代码从左到右,另一个从右到左.当我对它进行基准测试时,我得到了非常类似的结果(其中"时钟周期"是根据测量的clock.代码是在没有优化的情况下编译的.
所以我的问题是:现代处理器做的不仅仅是"缓存读取+ 64字节"吗？他们是向前和向后缓存吗？编译器可以"告诉"处理器代码向后迭代吗？
作为参考,我正在Mac OS X 10.13.3使用gcc-7 (Homebrew GCC 7.2.0_1) 7.2.0具有64字节缓存行的x86-64 Intel处理器.
Benchmakrs:
$ ./a.out
Backward Iterating...took 150101 clock cycles
$ ./a.out
Forward Iterating...took 146545 clock cycles
我希望前向迭代速度大约快64倍,因为每64个元素应该是缓存命中,而对于反向迭代,每个元素应该是缓存未命中.
所以,我打电话给cachegrind.两者的缓存命中率几乎相同:
# Left to right iteration
==21773==
==21773== I refs: 4,006,996,067
==21773== I1 misses: 5,183
==21773== LLi misses: 3,019
==21773== I1 miss rate: 0.00%
==21773== LLi miss rate: 0.00%
==21773==
==21773== D refs: 1,802,393,260 (1,401,627,925 rd + …可能重复:
生成随机枚举
可以说我有以下内容:
enum Color {
RED, GREEN, BLUE
};
Color foo;
我想要做的是随机地将foo分配给一种颜色.最直接的方式是:
int r = rand() % 3;
if (r == 0)
{
foo = RED;
}
else if (r == 1)
{
foo = GREEN;
}
else
{
foo = BLUE;
}
我想知道是否有更清洁的方法.我尝试过(并且失败了)以下内容:
foo = rand() % 3; //Compiler doesn't like this because foo should be a Color not an int
foo = Color[rand() % 3] //I thought this was worth a shot. Clearly didn't work.
如果你们知道任何更好的方式不涉及3 if语句,请告诉我.谢谢.
我需要能够从我的 C 代码访问汇编寄存器。我有一种简单的方法可以将寄存器的值设置为变量的值并将寄存器的值作为变量获取？希望这是有道理的......
我用C++编程.
这个问题基本上是我无法在任何地方找到答案.所以这是问题所在:
我想创建一个C风格的字符串,但我想将一个整数变量i放入字符串中.很自然地,我使用了一个流:
stringstream foo;
foo
<< "blah blah blah blah... i = "
<< i
<< " blah blah... ";
但是,我需要以某种方式获得一个C风格的字符串传递给一个函数(原来foo.str()返回一个std :: string).所以这在技术上是一个三部分问题 -
1)如何将std :: string转换为C风格的字符串？
2)有没有办法从字符串流中获取C风格的字符串？
3)有没有办法直接使用C风格的字符串(不使用字符串流)来构造一个带有整数变量的字符串？
我正在尝试从Rust哈希映射中获取密钥.我有以下基准:
#[bench]
fn rust_get(b: &mut Bencher) {
let (hash, keys) =
get_random_hash::<HashMap<String, usize>>(&HashMap::with_capacity, &rust_insert_fn);
let mut keys = test::black_box(keys);
b.iter(|| {
for k in keys.drain(..) {
hash.get(&k);
}
});
}
其中get_random_hash定义为:
fn get_random_hash<T>(
new: &Fn(usize) -> T,
insert: &Fn(&mut T, String, usize) -> (),
) -> (T, Vec<String>) {
let mut keys = Vec::with_capacity(HASH_SIZE);
let mut hash = new(HASH_CAPACITY);
for i in 0..HASH_SIZE {
let k: String = format!("{}", Uuid::new_v4());
keys.push(k.clone());
insert(&mut hash, k, i);
}
return (hash, …