Commit 5afb412ddcacc1a835e32fd98c75affb0af72800 - mozc

+0

-1

src/base/file_util_test.cc less more

36	36
37	37	#include "base/file_stream.h"
38	38	#include "base/logging.h"
39		#include "base/mmap.h"
40	39	#include "base/number_util.h"
41	40	#include "base/util.h"
42	41	#include "testing/base/public/gunit.h"

+23

-3

src/base/mmap.cc less more

43	43
44	44	#include "base/port.h"
45	45	#include "base/logging.h"
46		#include "base/system_util.h"
47	46	#include "base/util.h"
48	47
49	48	#ifdef OS_WIN

180	179	return false;
181	180	}
182	181
183		SystemUtil::MaybeMLock(ptr, size_);
	182	MaybeMLock(ptr, size_);
184	183	text_ = reinterpret_cast<char *>(ptr);
185	184	size_ = st.st_size;
186	185	return true;

188	187
189	188	void Mmap::Close() {
190	189	if (text_ != NULL) {
191		SystemUtil::MaybeMUnlock(text_, size_);
	190	MaybeMUnlock(text_, size_);
192	191	munmap(reinterpret_cast<char *>(text_), size_);
193	192	}
194	193

255	254	}
256	255	#endif // MOZC_USE_PEPPER_FILE_IO
257	256
	257	int Mmap::MaybeMLock(const void *addr, size_t len) {
	258	// TODO(yukawa): Integrate mozc_cache service.
	259	#if defined(OS_WIN) \|\| defined(OS_ANDROID) \|\| defined(__native_client__)
	260	return -1;
	261	#else // defined(OS_WIN) \|\| defined(OS_ANDROID) \|\|
	262	// defined(__native_client__)
	263	return mlock(addr, len);
	264	#endif // defined(OS_WIN) \|\| defined(OS_ANDROID) \|\|
	265	// defined(__native_client__)
	266	}
	267
	268	int Mmap::MaybeMUnlock(const void *addr, size_t len) {
	269	#if defined(OS_WIN) \|\| defined(OS_ANDROID) \|\| defined(__native_client__)
	270	return -1;
	271	#else // defined(OS_WIN) \|\| defined(OS_ANDROID) \|\|
	272	// defined(__native_client__)
	273	return munlock(addr, len);
	274	#endif // defined(OS_WIN) \|\| defined(OS_ANDROID) \|\|
	275	// defined(__native_client__)
	276	}
	277
258	278	} // namespace mozc

+19

-3

src/base/mmap.h less more

37	37	#include "base/port.h"
38	38
39	39	namespace mozc {
	40
40	41	class Mmap {
41	42	public:
42	43	Mmap();
43		~Mmap() {
44		Close();
45		}
	44	~Mmap() { Close(); }
	45
46	46	bool Open(const char filename, const char mode = "r");
47	47	void Close();
	48
	49	// Following mlock/munlock related functions work based on target environment.
	50	// In the case of Android, Native Client, Windows, we don't want to call
	51	// actual functions, so these functions do nothing and return -1. In other
	52	// cases, these functions call actual mlock/munlock functions and return it's
	53	// result.
	54	// On Android, page-out is probably acceptable because
	55	// - Smaller RAM on the device.
	56	// - The storage is (usually) solid state thus page-in/out is expected to
	57	// be faster.
	58	// On Linux, in the kernel version >= 2.6.9, user process can mlock. In older
	59	// kernel, it fails if the process is running in user priviledge.
	60	// TODO(team): Check in mac that mlock is really necessary.
	61	static int MaybeMLock(const void *addr, size_t len);
	62	static int MaybeMUnlock(const void *addr, size_t len);
48	63
49	64	#ifndef MOZC_USE_PEPPER_FILE_IO
50	65	char &operator[](size_t n) { return *(text_ + n); }

81	96
82	97	DISALLOW_COPY_AND_ASSIGN(Mmap);
83	98	};
	99
84	100	} // namespace mozc
85	101
86	102	#endif // MOZC_BASE_MMAP_H_

+32

-0

src/base/mmap_test.cc less more

96	96	FileUtil::Unlink(filename);
97	97	}
98	98	}
	99
	100	#if defined(OS_WIN)
	101	TEST(MmapTest, WindowsMaybeMLockTest) {
	102	size_t data_len = 32;
	103	void *addr = malloc(data_len);
	104	EXPECT_EQ(-1, Mmap::MaybeMLock(addr, data_len));
	105	EXPECT_EQ(-1, Mmap::MaybeMUnlock(addr, data_len));
	106	free(addr);
	107	}
	108	#elif defined(OS_MACOSX)
	109	TEST(MmapTest, MacMaybeMLockTest) {
	110	size_t data_len = 32;
	111	void *addr = malloc(data_len);
	112	EXPECT_EQ(0, Mmap::MaybeMLock(addr, data_len));
	113	EXPECT_EQ(0, Mmap::MaybeMUnlock(addr, data_len));
	114	free(addr);
	115	}
	116	#else
	117	TEST(MmapTest, LinuxMaybeMLockTest) {
	118	size_t data_len = 32;
	119	void *addr = malloc(data_len);
	120	#if defined(OS_ANDROID) \|\| defined(__native_client__)
	121	EXPECT_EQ(-1, Mmap::MaybeMLock(addr, data_len));
	122	EXPECT_EQ(-1, Mmap::MaybeMUnlock(addr, data_len));
	123	#else
	124	EXPECT_EQ(0, Mmap::MaybeMLock(addr, data_len));
	125	EXPECT_EQ(0, Mmap::MaybeMUnlock(addr, data_len));
	126	#endif // defined(OS_ANDROID) \|\| defined(__native_client__)
	127	free(addr);
	128	}
	129	#endif // OS_WIN, OS_MACOSX, else.
	130
99	131	} // namespace
100	132	} // namespace mozc

+3

-21

src/base/system_util.cc less more

65	65	#include "base/win_util.h"
66	66
67	67	#ifdef OS_ANDROID
	68	// HACK to avoid a bug in sysconf in android.
	69	#include "android/jni/sysconf.h"
	70	#define sysconf mysysconf
68	71	#include "base/android_util.h"
69	72	#endif // OS_ANDROID
70	73

1071	1074	#endif // OS_WIN
1072	1075	}
1073	1076
1074		int SystemUtil::MaybeMLock(const void *addr, size_t len) {
1075		// TODO(yukawa): Integrate mozc_cache service.
1076		#if defined(OS_WIN) \|\| defined(OS_ANDROID) \|\| defined(__native_client__)
1077		return -1;
1078		#else // defined(OS_WIN) \|\| defined(OS_ANDROID) \|\|
1079		// defined(__native_client__)
1080		return mlock(addr, len);
1081		#endif // defined(OS_WIN) \|\| defined(OS_ANDROID) \|\|
1082		// defined(__native_client__)
1083		}
1084
1085		int SystemUtil::MaybeMUnlock(const void *addr, size_t len) {
1086		#if defined(OS_WIN) \|\| defined(OS_ANDROID) \|\| defined(__native_client__)
1087		return -1;
1088		#else // defined(OS_WIN) \|\| defined(OS_ANDROID) \|\|
1089		// defined(__native_client__)
1090		return munlock(addr, len);
1091		#endif // defined(OS_WIN) \|\| defined(OS_ANDROID) \|\|
1092		// defined(__native_client__)
1093		}
1094
1095	1077	} // namespace mozc

+0

-16

src/base/system_util.h less more

208	208	// check endian-ness at runtime.
209	209	static bool IsLittleEndian();
210	210
211		// Following mlock/munlock related functions work based on target environment.
212		// In the case of Android, Native Client, Windows, we don't want to call
213		// actual functions, so these functions do nothing and return -1. In other
214		// cases, these functions call actual mlock/munlock functions and return it's
215		// result.
216		// On Android, page-out is probably acceptable because
217		// - Smaller RAM on the device.
218		// - The storage is (usually) solid state thus page-in/out is expected to
219		// be faster.
220		// On Linux, in the kernel version >= 2.6.9, user process can mlock. In older
221		// kernel, it fails if the process is running in user priviledge.
222		// TODO(horo): Check in mac that mlock is really necessary.
223		static int MaybeMLock(const void *addr, size_t len);
224
225		static int MaybeMUnlock(const void *addr, size_t len);
226
227	211	private:
228	212	DISALLOW_IMPLICIT_CONSTRUCTORS(SystemUtil);
229	213	};

+0

-35

src/base/system_util_test.cc less more

238	238	}
239	239	#endif // OS_ANDROID
240	240
241		#ifdef OS_WIN
242		TEST_F(SystemUtilTest, WindowsMaybeMLockTest) {
243		size_t data_len = 32;
244		void *addr = malloc(data_len);
245		EXPECT_EQ(-1, SystemUtil::MaybeMLock(addr, data_len));
246		EXPECT_EQ(-1, SystemUtil::MaybeMUnlock(addr, data_len));
247		free(addr);
248		}
249		#endif // OS_WIN
250
251		#ifdef OS_MACOSX
252		TEST_F(SystemUtilTest, MacMaybeMLockTest) {
253		size_t data_len = 32;
254		void *addr = malloc(data_len);
255		EXPECT_EQ(0, SystemUtil::MaybeMLock(addr, data_len));
256		EXPECT_EQ(0, SystemUtil::MaybeMUnlock(addr, data_len));
257		free(addr);
258		}
259		#endif // OS_MACOSX
260
261		TEST_F(SystemUtilTest, LinuxMaybeMLockTest) {
262		size_t data_len = 32;
263		void *addr = malloc(data_len);
264		#ifdef OS_LINUX
265		#if defined(OS_ANDROID) \|\| defined(__native_client__)
266		EXPECT_EQ(-1, SystemUtil::MaybeMLock(addr, data_len));
267		EXPECT_EQ(-1, SystemUtil::MaybeMUnlock(addr, data_len));
268		#else
269		EXPECT_EQ(0, SystemUtil::MaybeMLock(addr, data_len));
270		EXPECT_EQ(0, SystemUtil::MaybeMUnlock(addr, data_len));
271		#endif // defined(OS_ANDROID) \|\| defined(__native_client__)
272		#endif // OS_LINUX
273		free(addr);
274		}
275
276	241	} // namespace mozc

+2

-2

src/dictionary/system/system_dictionary.cc less more

55	55	#include <vector>
56	56
57	57	#include "base/logging.h"
	58	#include "base/mmap.h"
58	59	#include "base/port.h"
59	60	#include "base/string_piece.h"
60		#include "base/system_util.h"
61	61	#include "base/util.h"
62	62	#include "dictionary/dictionary_token.h"
63	63	#include "dictionary/file/dictionary_file.h"

597	597	// has the priviledge to mlock.
598	598	// Note that we don't munlock the space because it's always better to keep
599	599	// the singleton system dictionary paged in as long as the process runs.
600		SystemUtil::MaybeMLock(spec_->ptr, spec_->len);
	600	Mmap::MaybeMLock(spec_->ptr, spec_->len);
601	601	if (!instance->dictionary_file_->OpenFromImage(spec_->ptr, spec_->len)) {
602	602	LOG(ERROR) << "Failed to open system dictionary image";
603	603	return NULL;

+2

-2

src/dictionary/system/value_dictionary.cc less more

33	33	#include <string>
34	34
35	35	#include "base/logging.h"
	36	#include "base/mmap.h"
36	37	#include "base/port.h"
37	38	#include "base/string_piece.h"
38		#include "base/system_util.h"
39	39	#include "dictionary/dictionary_token.h"
40	40	#include "dictionary/file/dictionary_file.h"
41	41	#include "dictionary/pos_matcher.h"

79	79	// has the priviledge to mlock.
80	80	// Note that we don't munlock the space because it's always better to keep
81	81	// the singleton system dictionary paged in as long as the process runs.
82		SystemUtil::MaybeMLock(ptr, len);
	82	Mmap::MaybeMLock(ptr, len);
83	83	scoped_ptr<ValueDictionary> instance(new ValueDictionary(pos_matcher));
84	84	DCHECK(instance.get());
85	85	if (!instance->dictionary_file_->OpenFromImage(ptr, len)) {

+1

-1

src/mozc_version_template.txt less more

0	0	MAJOR=2
1	1	MINOR=17
2		BUILD=2097
	2	BUILD=2098
3	3	REVISION=102
4	4	# NACL_DICTIONARY_VERSION is the target version of the system dictionary to be
5	5	# downloaded by NaCl Mozc.