1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
#include "mapper.h"
// combined value list corresponding to a word <1,1,1,1....>
valueList *createNewValueListNode(char *value){
valueList *newNode = (valueList *)malloc (sizeof(valueList));
strcpy(newNode -> value, value);
newNode -> next = NULL;
return newNode;
}
// insert new count to value list
valueList *insertNewValueToList(valueList *root, char *count){
valueList *tempNode = root;
if(root == NULL)
return createNewValueListNode(count);
while(tempNode -> next != NULL)
tempNode = tempNode -> next;
tempNode -> next = createNewValueListNode(count);
return root;
}
// free value list
void freeValueList(valueList *root) {
if(root == NULL) return;
valueList *tempNode = NULL;
while (root != NULL){
tempNode = root;
root = root -> next;
free(tempNode);
}
}
// create <word, value list>
intermediateDS *createNewInterDSNode(char *word, char *count){
intermediateDS *newNode = (intermediateDS *)malloc (sizeof(intermediateDS));
strcpy(newNode -> key, word);
newNode -> value = NULL;
newNode -> value = insertNewValueToList(newNode -> value, count);
newNode -> next = NULL;
return newNode;
}
// insert or update a <word, value> to intermediate DS
intermediateDS *insertPairToInterDS(intermediateDS *root, char *word, char *count){
intermediateDS *tempNode = root;
if(root == NULL)
return createNewInterDSNode(word, count);
while(tempNode -> next != NULL) {
if(strcmp(tempNode -> key, word) == 0){
tempNode -> value = insertNewValueToList(tempNode -> value, count);
return root;
}
tempNode = tempNode -> next;
}
if(strcmp(tempNode -> key, word) == 0){
tempNode -> value = insertNewValueToList(tempNode -> value, count);
} else {
tempNode -> next = createNewInterDSNode(word, count);
}
return root;
}
// free the DS after usage. Call this once you are done with the writing of DS into file
void freeInterDS(intermediateDS *root) {
if(root == NULL) return;
intermediateDS *tempNode = NULL;
while (root != NULL) {
tempNode = root;
root = root -> next;
freeValueList(tempNode -> value);
free(tempNode);
}
}
// emit the <key, value> into intermediate DS
// eats the data into the DS
void emit(char *key, char *value) {
//Go through intermediateDS, comparing key in list to *key.
//If it exists, somehow add to the value list another "1" to the existing list.
//If it never does (use string compare thing), add it to the end along with the "1".
/* THIS IS NOT CURRENTLY IMPLEMENTED PROPERLY BUT SHOULD BE ABOUT RIGHT
CONCEPTUALLY.
intermediateDS *tempNode = NULL;
while (root != NULL) {
tempNode = root;
root = root -> next;
}
*/
}
// map function
void map(char *chunkData){
int i = 0;
char *buffer;
while ((buffer = getWord(chunkData, &i)) != NULL){
// get words from buffer & give it to emitter to be put into intermediateDS
}
// you can use getWord to retrieve words from the
// chunkData one by one. Example usage in utils.h
}
// write intermediate data to separate word.txt files
// Each file will have only one line : word 1 1 1 1 1 ...
// poops the data out into separate .txt files
void writeIntermediateDS() {
}
int main(int argc, char *argv[]) {
if (argc < 2) {
printf("Less number of arguments.\n");
printf("./mapper mapperID\n");
exit(0);
}
// ###### DO NOT REMOVE ######
mapperID = strtol(argv[1], NULL, 10);
// ###### DO NOT REMOVE ######
// create folder specifically for this mapper in output/MapOut
// mapOutDir has the path to the folder where the outputs of
// this mapper should be stored
mapOutDir = createMapDir(mapperID);
// ###### DO NOT REMOVE ######
while(1) {
// create an array of chunkSize=1024B and intialize all
// elements with '\0'
char chunkData[chunkSize + 1]; // +1 for '\0'
memset(chunkData, '\0', chunkSize + 1);
char *retChunk = getChunkData(mapperID);
if(retChunk == NULL) {
break;
}
strcpy(chunkData, retChunk);
free(retChunk);
map(chunkData);
}
// ###### DO NOT REMOVE ######
writeIntermediateDS();
return 0;
}
|
