ce67f6c · rowtype-yoga/purescript-native

git.iko.soy/rowtype-yoga/purescript-native

on golang help sign in

C++: small-map optimization

ce67f6cAndy Arvanitis11 years ago

pcc/Make.hs−1

compare with golang

unifiedsplit

@@ -122,7 +122,6 @@ buildMakeActions outputDir filePathMap usePrefix =

122 writeTextFile (outputDir </> "CMakeLists.txt") (fromString cmakeListsTxt)

123 writeTextFile (supportDir </> "PureScript.hh") $ B.unpack $(embedFile "pcc/include/purescript.hh")

124 writeTextFile (supportDir </> "PureScript.cc") $ B.unpack $(embedFile "pcc/include/purescript.cc")

125− writeTextFile (supportDir </> "map_key.hh") $ B.unpack $(embedFile "pcc/include/map_key.hh")

126

125

127 let inputPath = dropExtension $ getInputFile mn

126 let inputPath = dropExtension $ getInputFile mn

128 hfile = addExtension inputPath "hh"

127 hfile = addExtension inputPath "hh"

pcc/include/map_key.hhdeleted−56

@@ -1,56 +0,0 @@

1−///////////////////////////////////////////////////////////////////////////////

2−//

3−// Module : map_key.hh

4−// Copyright : (c) Andy Arvanitis 2015

5−// License : MIT

6−//

7−// Maintainer : Andy Arvanitis <andy.arvanitis@gmail.com>

8−// Stability : experimental

9−// Portability :

10−//

11−// Support for maps using keys with compile-time hashes.

12−//

13−///////////////////////////////////////////////////////////////////////////////

14−//

15−#ifndef PS_MapKey_HH

16−#define PS_MapKey_HH

17−

18−#include <cstring>

19−

20−namespace PureScript {

21−

22− struct map_key_t {

23−

24− const uint64_t hash;

25− const char * const cstr;

26−

27− // Compile-time (fnv-1a) hash function

28− static constexpr auto fnv1a(const char s[], const uint64_t hash = 14695981039346656037UL) -> uint64_t {

29− return !s[0] ? hash : fnv1a(s + 1, (hash ^ static_cast<unsigned char>(s[0])) * 1099511628211UL);

30− }

31−

32− class hasher {

33− public:

34− auto operator() (const map_key_t& key) const -> size_t {

35− return key.hash;

36− }

37− };

38−

39− class equal {

40− public:

41− auto operator() (const map_key_t& key1, const map_key_t& key2) const -> bool {

42− return (key1.cstr == key2.cstr) || strcmp(key1.cstr, key2.cstr) == 0;

43− }

44− };

45− };

46−

47− template <uint64_t H>

48− constexpr auto make_map_key(const char s[]) -> const map_key_t {

49− return map_key_t{H, s};

50− }

51−

52− #define KEY(k) make_map_key<map_key_t::fnv1a(k)>(k)

53−

54−} // namespace PureScript

55−

56−#endif // PS_MapKey_HH

pcc/include/purescript.cc+31−13

@@ -17,7 +17,6 @@

17namespace PureScript {

19#define COPY_DATA(src) \

20− type = src.type; \

21 switch (type) { \

20 switch (type) { \

22 case Type::Integer: i = src.i; break; \

21 case Type::Integer: i = src.i; break; \

23 case Type::Double: d = src.d; break; \

22 case Type::Double: d = src.d; break; \

@@ -37,7 +36,6 @@ namespace PureScript {

37 }

36 }

39#define MOVE_DATA(src) \

38#define MOVE_DATA(src) \

40− type = src.type; \

41 switch (type) { \

39 switch (type) { \

42 case Type::Integer: i = src.i; break; \

40 case Type::Integer: i = src.i; break; \

43 case Type::Double: d = src.d; break; \

41 case Type::Double: d = src.d; break; \

@@ -56,32 +54,34 @@ namespace PureScript {

56 default: assert(false && "Unsupported type in move"); \

54 default: assert(false && "Unsupported type in move"); \

57 }

55 }

59−any::any(const any& other) {

57+any::any(const any& other) : type(other.type) {

60 COPY_DATA(other);

58 COPY_DATA(other);

61}

59}

63−any::any(any&& other) noexcept {

61+any::any(any&& other) noexcept : type(other.type) {

64 MOVE_DATA(other);

62 MOVE_DATA(other);

65}

63}

67auto any::operator=(const any& rhs) -> any& {

65auto any::operator=(const any& rhs) -> any& {

66+ type = rhs.type;

68 COPY_DATA(rhs);

67 COPY_DATA(rhs);

69 return *this;

68 return *this;

70}

69}

72// Takes ownership -- might need to reconsider this

71// Takes ownership -- might need to reconsider this

73auto any::operator=(any& rhs) noexcept -> any& {

72auto any::operator=(any& rhs) noexcept -> any& {

73+ type = rhs.type;

74 MOVE_DATA(rhs);

75 return *this;

76}

78auto any::operator=(any&& rhs) noexcept -> any& {

79+ type = rhs.type;

79 MOVE_DATA(rhs);

80 MOVE_DATA(rhs);

80 return *this;

81 return *this;

81}

82}

83any::~any() {

84any::~any() {

84− // std::cout << "destroy" << std::endl;

85 switch (type) {

86 case Type::Integer: ; break;

87 case Type::Double: ; break;

@@ -225,10 +225,6 @@ any::operator string() const {

225 return cast<string>();

226}

227

228−any::operator std::string() const {

229− return cast<string>();

230−}

231−

232any::operator const map&() const {

228any::operator const map&() const {

233 RETURN_VALUE(Type::Map, m, *)

229 RETURN_VALUE(Type::Map, m, *)

234}

230}

@@ -257,16 +253,38 @@ auto any::extractValue(const any& a) -> const any& {

257 return a;

253 return a;

258}

254}

259

255

260−auto any::operator[](const map_key_t& rhs) const -> const any& {

256+auto any::operator[](const char rhs[]) const -> const any& {

261− RETURN_VALUE(Type::Map, m->at(rhs),)

257+ const any& val = extractValue(*this);

258+ assert(val.type == Type::Map);

259+ for (any::map::const_iterator it = val.m->begin(), end = val.m->end(); it != end; ++it) {

260+ if (it->first == rhs || strcmp(it->first, rhs) == 0) {

261+ return it->second;

262+ }

263+ }

264+ throw runtime_error("map key not found");

262}

265}

263

266

264auto any::operator[](const vector::size_type rhs) const -> const any& {

267auto any::operator[](const vector::size_type rhs) const -> const any& {

265− RETURN_VALUE(Type::Vector, v->at(rhs),)

268+ const any& val = extractValue(*this);

269+ assert(val.type == Type::Vector);

270+ return (*val.v)[rhs];

266}

271}

267

272

268auto any::operator[](const any& rhs) const -> const any& {

273auto any::operator[](const any& rhs) const -> const any& {

274+ const any& val = extractValue(*this);

275+ assert(val.type == Type::Vector);

269− RETURN_VALUE(Type::Vector, v->at(rhs.cast<long>()),)

276+ return (*val.v)[rhs.cast<long>()];

277+}

278+

279+auto any::contains(const char key[]) const -> bool {

280+ const any& val = extractValue(*this);

281+ assert(val.type == Type::Map);

282+ for (any::map::const_iterator it = val.m->begin(), end = val.m->end(); it != end; ++it) {

283+ if (it->first == key || strcmp(it->first, key) == 0) {

284+ return true;

285+ }

286+ }

287+ return false;

270}

288}

271

289

272//-----------------------------------------------------------------------------

290//-----------------------------------------------------------------------------

pcc/include/purescript.hh+11−6

@@ -29,9 +29,8 @@

29#include <functional>

30#include <string>

31#include <vector>

32−#include <unordered_map>

32+#include <utility>

33#include <stdexcept>

34−#include "map_key.hh"

36#define DECLARE_OPERATOR(op, ty, rty) \

35#define DECLARE_OPERATOR(op, ty, rty) \

37 friend auto operator op (const any&, ty) -> rty; \

36 friend auto operator op (const any&, ty) -> rty; \

@@ -48,9 +47,14 @@

48namespace PureScript {

47namespace PureScript {

50using string = const char *;

49using string = const char *;

51−using runtime_error = std::runtime_error;

52using nullptr_t = std::nullptr_t;

50using nullptr_t = std::nullptr_t;

52+// Workaround for missing C++11 version in gcc

53+class runtime_error : public std::runtime_error {

54+public:

55+ runtime_error(const char message[]) : std::runtime_error(std::string(message)) {}

56+};

57+

54const bool undefined = false;

58const bool undefined = false;

56// A variant data class designed to provide some features of dynamic typing.

60// A variant data class designed to provide some features of dynamic typing.

@@ -81,7 +85,7 @@ class any {

81 };

85 };

82 static constexpr as_thunk unthunk = as_thunk{};

86 static constexpr as_thunk unthunk = as_thunk{};

84− using map = std::unordered_map<const map_key_t, const any, map_key_t::hasher, map_key_t::equal>;

88+ using map = std::vector<std::pair<const char * const, const any>>;

85 using vector = std::vector<any>;

89 using vector = std::vector<any>;

86 using fn = auto (*)(const any&) -> any;

90 using fn = auto (*)(const any&) -> any;

87 using closure = std::function<any(const any&)>;

91 using closure = std::function<any(const any&)>;

@@ -214,14 +218,15 @@ class any {

214 operator bool() const;

218 operator bool() const;

215

219

216 operator string() const;

220 operator string() const;

217− operator std::string() const;

218 operator const map&() const;

221 operator const map&() const;

219 operator const vector&() const;

222 operator const vector&() const;

220

223

221− auto operator[](const map_key_t&) const -> const any&;

224+ auto operator[](const char[]) const -> const any&;

222 auto operator[](const vector::size_type) const -> const any&;

225 auto operator[](const vector::size_type) const -> const any&;

223 auto operator[](const any&) const -> const any&;

226 auto operator[](const any&) const -> const any&;

224

227

228+ auto contains(const char[]) const -> bool;

229+

225 auto extractPointer() const -> void*;

230 auto extractPointer() const -> void*;

226

231

227 static auto extractValue(const any&) -> const any&;

232 static auto extractValue(const any&) -> const any&;

src/Language/PureScript/Pretty/Cpp.hs+4−4

@@ -75,9 +75,9 @@ literals = mkPattern' match

75 [ return $ runType mapType ++ "{\n"

76 , withIndent $ do

77 cpps <- forM ps $ \(key, value) -> do

78− val <- prettyPrintCpp' value

78+ value' <- prettyPrintCpp' value

79− k <- prettyPrintCpp' (CppStringLiteral key)

79+ key' <- prettyPrintCpp' (CppStringLiteral key)

80− return $ "{ " ++ "KEY" ++ parens k ++ ", " ++ val ++ " }"

80+ return $ "{ " ++ key' ++ ", " ++ value' ++ " }"

81 indentString <- currentIndent

82 return $ intercalate ", \n" $ map (indentString ++) cpps

83 , return "\n"

@@ -306,7 +306,7 @@ indexer = mkPattern' match

306 match (CppIndexer (CppNumericLiteral (Left index)) val) = return (show index ++ "UL", val)

307 match (CppIndexer index val) = do

308 index' <- prettyPrintCpp' index

309− return ("KEY" ++ parens index', val)

309+ return (index', val)

310 match _ = mzero

311

312lam :: Pattern PrinterState Cpp ((String, [(String, Maybe CppType)], Maybe CppType), Cpp)